1、python的注释
认识注释：注释就是就是对代码的解释说明，注释的内容不会被当作代码运行
1、单行注释用#号
2、多行注释可以用三对双引号''''''
2、变量
2.1.变量名的命名规范
1、变量名只能是 字母、数字或下划线的任意组合
2、变量名的第一个字符不能是数字
3、关键字不能声明为变量名
2.2.变量名的命名风格
1、风格一：驼峰体
1）AgeOfDahai = 56
2、风格二：纯小写下划线(在python中，变量名的命名推荐使用该风格)
1）age_of_dahai = 56
2.3.变量值的三大特性
1、id
1）变量在内存中的唯一编号，内存地址不同id肯定不同，用法：id(变量)
2、type
1）变量值的类型，用法：type(变量)
3、value
1）变量值，print(变量)
3.输入和输出函数
3.1、input()函数
1、输入函数，接受用户输入数据，用一个变量来接，用法：变量 = input()
2、输入的数据都会变成字符串类型
3.2、print()函数
1、输出函数，把数据打印在控制台
4.数据类型(一) --- 数字类型Numbers
4.1、数字类型
1、int（长整型）
1）为了提高数字的可读性
2）Python 3.x 允许使用下划线
_作为数字(包括整数和小数)的分隔符。3）通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。
4）下划线不会影响数字本身的值
5）例：number = 1_301_547
2、float（浮点型）
1) 十进制形式
2) 指数形式
# 形式：aEn 或 aen
# 例：1.7E5 = 1.7×10^5，其中 1.7 是尾数，5 是指数
3、complex（复数）
1) 复数由实部和虚部构成，在 Python 中，复数的虚部以
j或者J作为后缀# 形式：a + bj
# 例：complex_ = 12 + 0.2j
4、bool（布尔型）
1）两个值：True，False
2）所有的数据类型都自带布尔值
3）None,0,空(空字符串，空列表，空字典,)三种情况下布尔值为False,
4）其余均为真4.2、整数的不同进制
1）十进制形式
# int() 函数可将整型数据(所有进制)转成十进制
2）二进制形式
# 由 0 和 1 两个数字组成，书写时以
0b或0B开头# bin() 函数可将整型数据(所有进制)转成二进制
3）八进制形式
# 八进制整数由 0~7 共八个数字组成，以
0o或0O开头# oct() 函数可将整型数据(所有进制)转成八进制
4）十六进制形式
# 由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以
0x或0X开头# hex() 函数可将整型数据(所有进制)转成十六进制
4.2、常用操作及内置方法：
1、常用操作：数学运算与比较运算
2、无内置方法
4.3、数字类型总结
1、只能存一个值
2、不可变类型，改变赋值，会改变原有地址
3、只有一个值，不存在有序无序之分
5.数据类型(二) --- 字符串类型String
5.1、字符串类型
1、Python中的字符串必须用英文的单引号或者双引号来指定
1）例："Hello World"，'Hello World'
2）双引号和单引号的性质是一样的
3）字符串的内容可以包含全世界的所有文字
2、处理字符串中的引号
1）双引号里面不能有双引号，如果需要使用双引号则需要转义，如："Hello, \"World"
2）单引号里面不能有单引号，如果需要使用单引号则需要转义，如：‘Hello, \‘World’
5.2、转义字符
1、\n 回车换行
2、\t tab制表符
3、\\ 一个\字符
4、\" 代表一个双引号
5、\' 代表一个单引号
5.3、字符串的格式化输出
1、占位符
1） %s占位符
# 可以接受字符和数字(全能)
# 例：print(“My name is %s” % “张三”)
2)%d 占位符
# %d 只能接受数字
# 例：print("My age is %d" % 18)
3）多个占位符的使用
# 多个值的话直接放到%后面要有括号
# 例：print(“My name is %s，my age is %s” % (“张三”,18))
2、format格式化
1）例：print(“My name is {}，my age is {}” % (“张三”,18))
2）位数与进制转换
# 保留两位有效数字，例："{:.2f}".format(3.14159)
# 转成二进制，例：'{0:b}'.format(12)，将12转成二进制
# 转成八进制，例：'{0:o}'.format(12)，将12转成八进制
# 转成八进制，例：'{0:x}'.format(12)，将12转成十六进制
3、f-string格式化
1）f-strings，比format使用简单，而且效率也更高
# 例：name="张三"， age=18
# print(f“My name is {name}，my age is {age}” )
5.4、增删改查
1、增
1）字符串拼接
# 1：print('hello' + 'world')
# 2：print(’hello‘，’world‘)
# 3：join(’‘.join(['hello', 'world']))
2、删
1）例：name = "张三"，del name
3、改
1）字符串为不可变类型，不可直接修改，需要引用，例：a = str.upper()
2）常用内置函数
# str.upper() 字符串字母全部变大写
# str.lower() 字符串字母全部变小写
# str.split() 把字符串切分成列表，默认空格字符切分
# str.replace(改，改成，改几个) 替换，不写第三个参数默认全部替换
# str.strip() 去掉字符串左右两边的字符，默认是空格字符，不管中间
4、查
1）索引和切片
# 索引用于获得字符串的一个字符，使用中括号[ ]作为索引的操作符
# 切片（顾头不顾尾，步长），查找字符串当中的一段值， [起始值:终止值:步长]
# 例：str_ = 'Hello World'
# 索引：str_[1]，str_[-1]# 切片：str_[1:5]， str_[1:5:2]，str_[1:5:2]，str_[1:5:-1]
2）成员运算
# 成员运算in和not in: 判断一个子字符串是否存在于一个大字符串中
# 返回布尔类型 True False
# 例：print("hello" in "hello world")，print("hello" not in "hello world")
3）查找
# str.find()，找到则返回起始索引，没找到会返回-1
# 例：str_ = "hello world"，str_.find("world")
# str.index()，找到则返回起始索引，没找到会报错
4）常用内置方法
# str.count() 统计
# str.isdigit() 判断字符串是不是全都是数字，True，False
# str.isalpha() 判断字符串是不是全都是字母，True，False
# str.startswith(obj) 判断字符串是不是以obj开头
# str.endswith(obj) 判断字符串是不是以obj结尾
# str.islower() 判断字符串中的值是否全是小写的
# str.isupper() 判断字符串中的值是否全是大写的
5.5、字符串类型总结
1、不可变类型，改变字符串会改变原有地址
2、有序的序列，支持下标访问
6.数据类型(三) --- 列表List
6.1、列表
1、列表是包含0个或多个元素组成的有序列表，属于有序序列类型
2、列表没有长度的限制，元素类型可以不l同，不需要预定义长度
3、列表创建
1）使用 [ ] 直接创建列表
2）使用 list() 函数创建列表，可以将其它数据类型转换为列表类型
# 不包括数字类型，字典只有key值能被转换
6.2、增删改查
1、增
1）list.append(element) # 在列表末尾追加一个元素
2）list.extend(obj) # 不会把列表或者元祖视为一个整体，按元素逐个添加
3）list.insert(index，element) # 在索引位置插入一个元素
2、删
1）变量全部删掉 # del L
2）索引删除 # del L[0]
3）常用内置方法
# list.remove(element) 指定元素删除
# list.pop(index) 从列表里面拿走一个值，按照索引删除值，默认是删除最后一个
# list.clear() 清空列表
3、改
1）列表是在原值上面修改，所以是可变类型
2）常用内置方法
# list.reverse() 反序
# list.sort() 对列表中元素进行排序，要求列表中元素类型统一
>> list.sort(reverse=True) 倒序排序
4、查
1）索引和切片
# 注意：字符串取的是字符，列表取的是一个数据类型/元素
# 索引用于获得列表的一个元素，使用中括号[ ]作为索引的操作符
# 切片（顾头不顾尾，步长），查找列表当中的一段值， [起始值:终止值:步长]
# 例：lst = ["a", 11, ["ab", 22], {"b": 11}, "c"]
# 索引：lst[1]，lst[-1]，lst[2][1]
# 切片：lst[1:2]，lst[1:4:2]
2）常用内置方法
# list.count(element) 查看列表某个元素的个数
# list.index(element) 查看列表的某个值所在的下标/索引，从左至右查找，
找到了返回该值的下标/索引，没找到报错
6.3列表推导式
1、列表推导式的效率均比普通的for循环效率更高
2、列表推导式返回列表，表达式在中括号[ ]中
3、式子：[x for x in iterable if expression]
6.4、列表总结
1、可变类型，改变列表元素不会改变列表地址
2、有序的序列，支持下标访问
7.数据类型(四) --- 元组Tuple
7.1、元组
1、元组一旦被创建，它的元素就不可以被更改，所以元组是不可变序列
2、元组可以看做是不可变的列表，元组主要用于保存无需修改的内容
3、注意：当创建的元组中只有一个元素时，该元素后面必须要加一个逗号，否则 Python 解释器就会将它视为元组类型。
4、元组创建
1）使用 ( ) 直接创建
2）使用tuple()函数创建元组，将其它数据类型转换为元组类型
7.2、增删改查
1、查
1）索引和切片
# 与列表相似
# 索引用于获得元组的一个元素，使用中括号[ ]作为索引的操作符
# 切片（顾头不顾尾，步长），查找元组当中的一段值， [起始值:终止值:步长]
2）常用内置方法
# list.count(element) 查看元组某个元素的个数
# list.index(element) 查看元组的某个值所在的下标/索引，从左至右查找，
找到了返回该值的下标/索引，没找到报错
2、元组不能修改，无法进行 (增，删，改)操作
1）元组是包含0个或多个元素组成的有序序列，元素类型可以不同
# 元组内元素不可修改，元组内的列表、字典、集合中的元素是可修改的，因为
>>列表、字典、集合是可修改类型
# 元素能不能修改要看数据类型所在的容器是否允许修改
7.3、元组总结
1、不可变类型，不能修改元组
2、有序的序列，支持下标访问
8.数据类型(五) --- 字典Dict
8.1、字典
1、散列类型，不可以进行索引取值， 没有顺序，可变序列，可以嵌套
2、字典的元素以键值对(key-value) 的形式存储
3、键必须唯一，并且必须不可变
4、value可以是任意的数据类型，而key只能使用数字、字符串或者元组，不能使用列表
5、字典创建
1）使用 { } 创建字典
2）通过 fromkeys(list，value=None) 方法创建字典
3）通过 dict() 映射函数创建字典
8.2、增删改查
1、增
1）直接赋值：dict[key] = value # 不存在key，有则覆盖
2）setdefault(key，value) # 有就不添加，没有就添加
2、删
1）dict.clear() # 清空字典
2）del dict[key] # 指定删除键值对，不存在的key会报错
3）dict.pop() # 删除，返回值是value，实际上就是拿走了字典的value，
不存在的key会报错
4）dict.popitem() # 最后一对键值对删除，返回的是一个元组
3、改
1）直接修改：dict[key] = value
2）dict.update(key: value) # update添加键值对
4、查
1）dict[key] # 查一个不存在的key会报错
2）dict.get(key) # get方法查找value，没有key就返回None，不会报错
3）dict.keys() # 取出所有的key
4）dict.values() # 取出所有的value
5）dict.items() # 查看所有的键值对
8.3、字典推导式
1、字典推导式的效率均比普通的for循环效率更高
2、字典推导式返回字典，表达式在大括号{ }中
3、式子：{key: value for (key, value) in iterable}
8.4、字典总结
1、可变类型， 没有顺序，无重复key
2、改变字典元素不会改变字典地址
3、散列类型，key-value类型，通过key取值
9.数据类型(六) --- 集合Set
9.1、集合
1、集合，散列类型，用来保存不重复的元素，集合中的元素都是唯一的，可变类型
2、同一集合中，每一个值都必须是不可变类型，包括整形、浮点型、字符串、元组
3、无法存储列表、字典、集合这些可变的数据类型
4、set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同
5、集合创建
1）使用 {} 创建
2）set(iteration)函数创建集合
9.2、增删改查
1、增
1）set.add(element) # 重复的数据不会被添加
2）set.update(iteration) # update添加多个值，list会被拆分成元素
2、 删
1）set.pop() # pop，从第一个元素删除
2）set.remove(element) # remove指定删除
3）set.discard() # 删除集合中指定数据，如果数据不存在也不会报错
3、改
1）要修改集合的元素，只能通过转换来修改，即将集合转换为列表，然后修改数据
再将列表转换为结合
# set = list(set) 集合转换成列表
4、查
1）由于集合是无序的，不存在索引，所以不能通过索引来获取集合的值，
可以通过for循环获取
2）也可以通过转换为有序的对象来获取，如将集合转换为列表
9.3、集合操作
1、去重
1）集合的一个用法：对数据去重
2）局限性
# 无法保证原数据类型的顺序
# 当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
2、set集合做交集、并集、差集运算
1）交集：set1 & set2 # 取两集合公共的元素
2）并集：set1 | set2 # 取两集合全部的元素
3）差集：set1 - set2 # 取一个集合中另一集合没有的元素
4）对称差集：set1 ^ set2 # 取集合 A 和 B 中不属于 A&B 的元素
9.4、frozenset 不可变集合
1、frozenset 集合是不可变序列，程序不能改变序列中的元素
2、当集合的元素不需要改变时，可以使用 fronzenset 替代 set，这样更加安全
9.5、集合总结
1、无序无索引集合，无重复数据，可变类型
2、集合中，每一个值都必须是不可变类型
10、其他的知识点
10.1、成员运算
1、成员运算 in 和 not in
1）判断元素是否在序列中，返回值是布尔类型
2）字典的成员运算判断的是key
10.2、同一性运算符
1、is 为同一性运算符
2、“==” 与 is 比较
1）“==” 主要用于判断两个对象的 value 是否相等
2）“is” 主要用于比较两个变量是否指向了同一个对象，即 “id”是否相同
3）在python中，为了节省内存，设置了缓存机制，使得简单整型和字符串这种不可变
类型的数据不会创建新对象，而是对它们进行缓存
10.3、和序列相关的内置函数
1、len() # 返回序列的长度
2、max() # 找出序列中的最大元素
3、min() # 找出序列中的最小元素
4、list() # 将序列转换为列表
5、str() # 将序列转换为字符串
6、sum() # 计算元素和
7、sorted() # 对元素进行排序
8、reversed() # 反向序列中的元素
9、enumerate() # 将序列组合为一个索引序列，多用在 for 循环中
10.4、数字类型的运算符
1、算术运算符号
1）加(+)、减(-)、乘(*)、除(/)、整除 (// 取整数部分)、取余(% 取余数部分)、乘方(**)
2、比较运算符
1）等于(==)，不等于(!=)，大于(>)，小于(<)，大于或等于(>=)，小于或等于(<=)
3、逻辑运算符
1）and（与）、or（或）、not（非）
4、赋值运算符
1）赋值(=)，加赋值(+=)，减赋值(-=)，乘赋值(*=)，除赋值(/=)，取余数赋值(%=)
2）幂赋值(**=)
5、位运算符
1）按位与(&)，按位或(|)，按位异或(^)，按位取反(~)
2）按位左移(<<)，8 << 2，表示整数 8 按位左移 2 位
3）按位右移(>>)，8 >> 2，表示整数 8 按位右移 2 位
6、优先级
1) () # 括号
2）** # 指数（最高优先级）
3）~ + - # 位运算符(非)，正号，负号
4）* / % // # 乘、除、取模和取整数
5）+ - # 加，减
6）>> << # 右移、左移（位运算符）
7）& # 位运算符(与)
8）^ | # 异或、或（位运算符）
9）< <= > >= # 比较运算符10）== != # 等于、不等于
11）= %= /= //= -= += *= **= # 赋值运算符
12）is is not # 身份运算符
13）in not in # 成员运算符
14）not and or # 逻辑运算符10.5其他常用函数
1、type()和isinstance()
1）type() # 查看变量的类型
2）isinstance(object, classinfo) # 判断一个对象是否为某个类的对象，返回布尔值
3）两者区别
# type() 不考虑继承关系。
# isinstance() 考虑继承关系
2、eval()函数
1）可以将符合元组、列表、字典结构的字符串，转换成列表、元组或者字典
3、map()和reduce()
1）map(function,iterator) # 根据提供的函数对指定序列做映射
2）reduce(function, iterable) # 会对参数序列中元素进行累积
4、filter()
1）用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
5、zip()函数
1）zip([iterable, …]) # 可以多个迭代器对象打包成一个元组
11、可迭代对象与迭代器和生成器
11.1、迭代对象与迭代器
1、迭代
1）单纯的重复不是迭代
2）迭代是一重复的过程，每一次重复都是基于上一次的结果而来
3）需要这样迭代取值的数据类型： 字符串、列表、元组、字典、集合、文件等
# 某些数据类型不能通过索引取值，所以我们需要一种不依赖索引取值的方式
# 迭代器提供了一种通用的且不依赖于索引的迭代取值方式的功能
2、可迭代对象
1）可迭代的对象iterable：但凡内置有__iter__方法的对象都称之为可迭代的对象
2）因为__iter__方法这个方法可以生成迭代器
3）字符串、列表、元组、字典、集合、文件等都是有__iter__()方法，所以都是可迭代 对象，数字类型没有就不是可迭代对象
3、迭代器
1）执行可迭代对象下的__iter__方法，返回的值就是一个迭代器
2）迭代器通过__next__()来获取下一个数据
3）迭代器取干净时，会报出StopIteration错误，被当成一种结束信号
4）在python中每个需要取值的数据类型都加了__iter__方法，可以变成迭代器
5）还有的直接就是迭代器，比如文件
6）注意：
# 调用可迭代的对象__iter__得到的是迭代器
# 执行迭代器__iter__方法得到的仍然是迭代器本身，为了for循环，
# for循环就是一种不依赖索引取值的方式，内置函数 iter()，next()
# for循环每次在遍历之前都先调用一次__iter()__方法，把可迭代对象对象变成了
迭代器，然后使用迭代器协议去实现循环访问
11.2、生成器Generator
1、生成器对象
1）但凡函数内包含yield关键字，调用函数不会执行函数体代码，会得到一个返回值，
该返回值就是生成器对象
2、yield
1）yield只能在函数内使用
# yield提供了一种自定义迭代器的解决方案
# yield可以保存函数的暂停的状态
# yield一般和for搭配使用
2）yield对比return
# 相同点：都可以返回值，值的类型与个数都没有限制
# 不同点：yield可以返回多次值（暂停），而return只能返回一次值函数就结束了