3-4各进制的表示和转换
二进制 0b
八进制 0o
十六进制 0x
bin（） 转换为二进制
int () 转换为十进制
oct() 转换为八进制
hex() 转换十六进制
3-5布尔类型与复数
True 真 False 假 必须大写
bool() 转换为布尔值
’‘ ,[] , 0, {} ,None 所有空值都会转换为False
3-6字符串
单引号
双引号
三引号 用于表示多行字符串
3-8转义字符
\n 换行
\r 回车
\` 引号
3-9 原始字符
r'字符串' \不会被转义
print('c:\northwind\northwest')
输出
c:
orthwind
orthwest
print(r'c:\northwind\northwest')
输出
c:\northwind\northwest
3-10字符串运算
字符串拼接 +
[] 通过下标获取某个字符
[0:n] 截取从第一个到第n-1个字符串
[0:-n] 截取从第一个到倒数第n个字符串
-n 代表的是步长 倒着数
[n:] 截取从第n+1个到最后一个字符串
[-n:] 从最后一个开始取n个字符串
4-1列表 list
[1,2,3]截取方法基本同 字符串
4-3 元组
（1，2，3）截取方法基本同字符串
定一个元素的元组 （1，）
空元组 （）
4-4序列总结
int float bool complex Number类型
str（不可变） list tuple（不可变） 序列类型
in 是否在序列中
not in 不在序列中
len 序列长度
max min 序列最大最小值 根据ascll码比较大小
ord（） 返回ascll码值
4-5 set集合
{} 无序 没有索引 不能切片
in 是否在集合中
not in 不在集合中
len 集合长度
{1,2,3,4} -{3,4} 输出{1,2} 差集
{1,2,3,4} & {3,4} 交集
{1,2,3,4} | {3,4,5} 并集
定义一个空的集合 通过关键字set()
4-6dict字典
{key:value,key2:value2}
key必须是不可变的类型
key是唯一的
key可以是str也可以是int
5-3 值类型与引用类型
int str tuple（不可改变）值类型
list set dict (可变) 引用类型
id() 查看某个数据在内存中的地址
5-5运算符号
5-9 逻辑运算符
and 如果第一个运算数返回 false 就不会执行第二个运算数 直接返回 false
or 如果第一个运算数返回 true 就不会执行第二个运算数 直接返回 true
not
5-10 成员运算符
in 是否在某一个组中 （在字典中 是否存在key）
not in
5-11 身份运算符
is 如果两个变量的身份相同，则返回true （注意不是值相等 ==）
not is
5-12 判断变量的值、身份、类型
isinstance(变量名，类型)
对象的三个特征 值 、 身份 、类型如何判断
对应方法 == 、 is 、 isinstance
5-13 位运算符
& 、| 、^ 、~ 、<< 、>>
把数字当作二进制进行运算
6-1 什么是表达式
表达式（expression）是运算符(operator)和操作数(operand)所构成的序列
6-2 表达式的优先级
not > or > and
优先级相同的情况下是 左结合（从左往右）
但是赋值运算符 = 右结合
6-12 elif
可以利用 if elif else 来模拟 其他语言中的switch函数 也可以使用字典来模拟
7-3 for range
# range(起始位置，偏移量，间隔 ) for x in range(0,10,2): print(x, end=' | ')# range(起始位置，终止位置，间隔 ) for x in range(10,0,-2): print(x, end=' | ')7-6 包、模块、类、函数/变量
包 - 文件夹 文件夹下必须有 __init__.py 作为一个模块，否则不会认为是一个包,只会认为是一个普通的文件夹
模块-文件
一个模块可以有多个类
函数和变量是模块的属性
7-7 导入
# import t.c7 # print(t.c7.a)from t.c7 import a print(a)
# 约束 * 可以在对应的模块 通过 模块的内置属性 __all__ = [变量名1，变量名2]from t.c7 import * print(a)
print(b)
print(c)
7-9 __init.py__的用法
用于批量导入模块
在t文件夹下的 __init.py__ 中引入
import sysimport datetimeimport io在其他模块只需要
import t7-11 普通模块内置变量
dir() 获取当前模块下所有的变量
''' this is a c9 doc'''# 命名空间+ 变量名称print('name:'+__name__)# 包名称print('package:'+__package__)# 模块的注释print('doc:'+__doc__)# 文件路径print('file:'+__file__)7-12 入口文件和普通模块内置变量的区别
name:t.t1.c9
package:t.t1
doc:
this is a c9 doc
file:/Users/leon/Desktop/study/python/lesson/lesson7/t/t1/c9.py
-----------------------------------
name:__main__
package:该模块不属于任何包
doc:
this is a c15 doc
file:/Users/leon/Desktop/study/python/lesson/lesson7/c15.py
leondeMacBook-Pro% 入口文件的name : __main__ 并且不属于某一个包下
7-13 __name__
可以用作判断当前模块 有没有作为一个程序入口去执行
if __name__ == '__main__': print('this is app')print('this is a module')python -m seven.t.t.c9 -m后面跟上命名空间 +包 模块
7-14 相对导入和绝对导入
顶级package包一直与 main.py文件同级
8-2 函数的定义及运行特点
def funcName(list): pass8-3 如何让函数返回多个结果
def damage(skill1,skill2): damage1 = skill1 * 3 damage2 = skill2 * 2 + 10 return damage1, damage2return 多个结果用逗号隔开，结果类型是一个元组
8-4 序列解包和链式赋值
d = 1,2,3a,b,c = dprint(a,b,c)8-5 必须参数和关键字参数
def add(x,y): #形参 result = x + y return resultc = add(1,2) #实参c = add(y=2,x=1) #关键字参数8-6 默认参数
def print_student_files(name,sex = '男',age = 16,school = '泡桐树高中'): print('我叫'+str(name)) print('我是'+str(sex) +'生') print('我今年'+str(age) + '岁') print('我在'+str(school) +'上学')print_student_files('小明')print_student_files('小王','女')print_student_files('小张',age = 15)8-7 可变参数
def demo(*params): print(params) print(type(params))demo(1,2,3,4,5,6)def demo(param1,*params,param2 = 2): print(param1) print(param2) print(params)demo('a',1,2,3,4,5,6,param2= 'params')8-8 关键字可变参数
#任意个关键字参数def city_temp(**params): # print(params) # print(type(params)) for key,value in params.items(): print(key,':',value) city_temp(bj='36c',xm = '38c', sh = '31c')
#任意个关键字参数def city_temp(**params): # print(params) # print(type(params)) for key,value in params.items(): print(key,':',value)a = {'bj':'36c','xm':'38c','sh':'31c'}city_temp(**a)8-9变量作用域
python中只有函数作用域，没有块集作用域。 if while for都是代码块 ，所以定义在其中的变量等同于定义在他们所处的函数作用域中
8-10 作用域链
通过作用域逐级向上查找变量
8-11 global关键字
def demo(): global c c = 50 demo()print(c) global定义一个全局变量
9-1 类的定义
# 有意义的面向对象的代码# 类 = 面向对象# 类、对象# 实例化# 类最基本的作用：封装class Student(): name = '' age = 0 def print_file(self): print('name:' + self.name) print('age:' + str(self.age))student = Student()student.print_file()9-4 类与对象
# 类是现实世界或思维世界的实体在计算机中的反映 它将数据以及这些数据上的操作封装在一起# 有意义的面向对象的代码# 类 = 面向对象# 类、对象# 实例化# 类最基本的作用：封装#模版class Student(): name = '' age = 0 def __init__(self,name,age): #构造函数 #初始化对象的属性 self.name = name self.age = age # 行为与特征 def do_homework(self): print('homework')student1 = Student('石敢当',18)print(student1.name)9-9 在实例方法中访问实例变量与类变量
__class__ 可以访问一个实例的类
class Student(): # 一个班级里所有学生的总数 sum1 = 0 # name = '' # age = 0 #类变量 实例变量 def __init__(self,name,age): #构造函数 #初始化对象的属性 self.name = name self.age = age print(self.__class__.sum1)
#print(Student.sum1) # 行为与特征 def do_homework(self): print('homework')student1 = Student('石敢当',18)# student2 = Student('喜小乐',18)# print(student1.__dict__)# print(Student.__dict__)9-10 类方法
通过装饰器 @ classmethod 来定义一个类方法， 约定必须传入第一个参数 cls（参数名可变）
通过装饰器 @staticmethod 来定义一个静态方法
class Student(): # 一个班级里所有学生的总数 sum1 = 0 # name = '' # age = 0 #类变量 实例变量 def __init__(self,name,age): #构造函数 #初始化对象的属性 self.name = name self.age = age # self.__class__.sum1 += 1 # print('当前班级学生总数为' + str(Student.sum1)) # 行为与特征 def do_homework(self): print('homework') #装饰器 类方法 @classmethod def plus_sum(cls): cls.sum1 += 1 print(cls.sum1)student1 = Student('石敢当',18)Student.plus_sum()student2 = Student('喜小乐',18)Student.plus_sum()9-12 成员可见性 公开和私有
实例的私有变量和方法会被转化为 类名__变量名
9-13 继承
c5.py
from c6 import Humanclass Student(Human): #类变量 实例变量 def __init__(self,school,name,age): self.school = school # Human.__init__(self,name,age) super(Student,self).__init__(name,age) # self.__score = 0 # self.__class__.sum1 += 1 # 行为与特征 def do_homework(self): super(Student,self).do_homework() print('homework')student1 = Student('人民路小学','石敢当',18)student1.do_homework()# print(student1.sum)# print(Student.sum)# print(student1.name)# print(student1.age)# student1.get_name()c6.py
class Human(): sum = 0 def __init__(self,name,age): self.name = name self.age = age def get_name(self): print(self.name) def do_homework(self): print('this is a parent method')10-3 字符集
#字符集import res = 'abc, acc, adc, aec, afc, ahc'# 普通字符和元字符一起使用时，普通字符主要起 定界的作用 ，[]或 ^ 取反r = re.findall('a[^cf]c',s)print(r)10-4 概括字符集
#概括字符集# \d \D
# \w [A-Za-z0-9_] 单词字符 \W 非单词字符
# \s 空白字符 \S 非空白字符import re
a = 'python 11\t11java&678p\nh\rp'
r = re.findall('\s', a)print(r)10-5 数量词
#数量词import re a = 'python 1111java678php'#贪婪与非贪婪r = re.findall('[a-z]{3,6}?',a)print(r)10-7 匹配0次1次或者无限多次
#数量词# * 匹配前一个字符0次或者无限多次# + 匹配前一个字符1次或者无限多次# ？匹配前一个字符0次或者1次import re a = 'pytho0python1pythonn2'#贪婪与非贪婪r = re.findall('python?',a)print(r)10-8 边界匹配符
#边界匹配import reqq = '10000001'# 4~8r = re.findall('^\d{4,8}$',qq)print(r)10-9 组
#组import rea = 'PythonPythonPythonPythonPython'# 4-8 r = re.findall('(Python){3}',a)print(r)10-10 匹配模式参数
#匹配模式参数import rea = 'PythonC#\nJavaPHP'# 4-8 r = re.findall('c#.{1}',a, re.I | re.S)print(r)10-11 re.sub 正则替换
#re.sub 正则替换import relanuage = 'PythonC#JavaC#PHPC#'def convert(value): matched = value.group() print(matched) return '!!' + matched + '!!' r = re.sub('C#',convert,lanuage)# r = lanuage.replace('C#','Golang')print(r)10-13 search与match函数
import res = '8C3721D86'# search 和 match 遇到符合条件的就会结束r = re.match('\d',s)print(r.span())r1 = re.search('\d',s)print(r1.group())r2 = re.findall('\d',s)print(r2)
10-14 group分组
import res = 'life is short , i use python,i love python'r = re.search('life(.*)python(.*)python',s)r1 = re.findall('life(.*)python',s)print(r.group(0,1,2))print(r.groups())print(r1[0])10-18 反序列化
import jsonjson_str = '[{"name":"leon", "age":18,"flag":false},{"name":"leon", "age":18}]'#反序列化 由字符串到某一个编程语言的数据结构student = json.loads(json_str)print(type(student))print(student)10-19 序列化
import jsonstudent = [ {"name":"leon", "age":18,"flag":False}, {"name":"leon", "age":18} ]json_str = json.dumps(student)print(json_str)print(type(json_str))11-2 枚举和普通类
枚举类型 ：
1.值不可变
2.防止相同的标签
11-3 枚举类型、枚举名称、枚举的值
# 类型from enum import Enumclass VIP(Enum): YELLOW = 1 GREEN = 2 BLACK = 3 RED = 4# 别名class Common(): YELLOW = 1#枚举类型、枚举名称、枚举的值# print(VIP.GREEN.name)# print(VIP.GREEN.value)# print(VIP.YELLOW)# print(VIP['GREEN'])for v in VIP: print(v)11-10 闭包
# 闭包 = 函数 + 环境变量 （函数定义时候）# 现场def curve_pre(): a = 25 def cureve(x): return a*x*x return curevea = 10f = curve_pre()print(f(2))12-1 匿名函数
# 匿名函数 lambda
# lambda parameter_list: expressiondef add(x,y): return x + yprint(add(1,2))
f = lambda x,y: x + yprint(f(1,2))12-7 命令式编程和函数式编程
