一、流程控制：if，while ，for
1、if……else 条件判断 语法： if 条件1： 代码块 elif 条件2： 代码块 …… else： 代码块
注：单纯的if语句里，从上到下，只要符合其中一个条件，就不会再执行下面的条件了。
2、while 无限循环
语法格式：（代码块可以是for循环或if条件判断循环，break，continu）
while 条件： 代码块 --------------------------- while 条件成立时执行下面的代码块，不成立时执行else代码块，但一遇到break就直接退出循环，循环里的或else都不会执行： 代码块 else： 代码块 ----------------------------
1 1、第一种情况 2 n = 1 3 while n < 5： 4 n +=1 5 print(n) -----> 2,3,4,5 6 7 2、第二种情况 8 n = 1 9 while n < 5: 10 print(n) ------->1,2,3,4 11 n +=1 12 13 3、第三种情况 14 while n < 5: 15 if n == 3: 16 break 17 print(n) 18 n +=1 19 ------->什么都没有，因为n =1或2时都不符合if条件，故不会执行里面的代码 20 21 4、第四种情况 （print（）缩进很重要，缩进很重要，缩进很重要！！！） 22 while n < 5: 23 if n == 3: 24 break 25 print(n) --------->1,2 26 n +=1 27 等效果下面if---else 28 while n < 5: 29 if n == 3: 30 break 31 else： 32 print(n) 33 n +=1 34 注：if条件判断，一旦符合条件，就不会再去看其他条件了，故else也不会去执行了，只有在while或for循环中才会去执行。 35 36 37 38 5、第五种情况 39 while n < 5: 40 print(n) 41 n +=1 42 else: 43 print("没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息") 44 45 >>> 1,2,3,4 46 >>> 没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息 47 48 6、第六种情况 49 while n < 5: 50 print(n) 51 n +=1 52 else: 53 print("没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息") 54 print("只要不出现死循环，不管前面程序执行如何，在while循环外的代码都会执行") 55 56 >>> 1,2,3,4 57 >>> 没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息 58 >>>只要不出现死循环，不管前面程序执行如何，在while循环外的代码都会执行
break 退出当前循环，如果外面还有循环，不会退出！！！
3、for ……else
语法格式：（同while循环，for循环是可控的循环，一般不作为无限循环） s = "321" counts = 0 if counts < len(s): for i in s: print("倒数第%s秒"%(i)) counts += 1 else: print("出发") else： print("这个打印是不会显示的，因为if里执行了上面的条件，下面就不会去执行的")
注意：当for循环结束后，会从上往下执行后面的代码即else，可以看作和for没有关系的另一个平行代码块
二、数据类型之间的转换
不可哈希的数据类型即可变数据类型：list、dict、set
可哈希的数据类型即不可变数据类型：int、str、tuple、bool
str 变成 list ：split(分割符) 或 list(str) 只是把每个元素放入列表中
list 变成 str ：list_str = "拼接符或空格"join(list) 或str(list) 只是外层加双引号，意义不大
1 # str 与 list的转换 2 # str ->list的转换1：通过 split() 方法将str改为list 3 str01 = "china_is_my_country" 4 str01 = str01.title() # China_Is_My_Country 5 str_list = str01.split("_") # ['China', 'Is', 'My', 'Country'] 6 7 # str ->list的转换2：通过list()方法转换的str是将一个列表会将每一个元素都切开，有时可能无法达到自己的预想，就用split(分割符) 8 str_list0 = list(str01) 9 # ['C', 'h', 'i', 'n', 'a', '_', 'I', 's', '_', 'M', 'y', '_', 'C', 'o', 'u', 'n', 't', 'r', 'y'] 10 11 # list ->str 的转换1：通过str()方法将list转成一个整体的str包括[]及双引号等如"[1,2,3]",这种转换没有太大意义 12 # list ->str 的转换2：通过join()方法将list里每个元素拼接起来 13 lis = ["我","爱","中","国"] 14 lis_str = "_".join(lis) # 我_爱_中_国
str 通过list(str)、tuple(str)、set(str) 对象方法转换成str ，只是在外加了一层双引号，对元素操作很不方便，故这种转换没有意义
注：str 、list、tuple、set、int 无法通过dict(）转换成字典，因字典是键值对成对存在的 (ValueError: dictionary update sequence element #0 has length 1; 2 is required)
注：想把str转换成int，str必须全是数字才行，不然报错
str通过对应对象方法变成 list 、tuple、set 、int 都是将str每个字符拆分迭代的放入对应数据类型中
---------------
非空字符串、列表、元组、字典、集合及非零数字转换成bool型 都为True
0，None，[]，（），{}，set（），False ，bytes" 转换成bool型都为 False
三、数据类型：
不可变数据类型：int、str、bool、tuple、frozenset
可变数据类型：list、dict、set
公共方法：count()、len()、del、copy()
len(所有都有)
count（数字、字典、集合没有此方法）
index（数字、字典、集合没有此方法）
可变数据类型都有copy（）
整数、字符串、列表、元组、布尔可以相加（字典、集合不可相加）
整数： int
# 不可变数据类型，无序 数学运算：+ - * / //(整除) % **（幂） 比较运算： >,<,>=,<=,==,!= 赋值运算：=,+=,*=,/=,-=,%=,,//=,**= 逻辑运算：not or and 从左到右 优先级：（） not and or 1(非零整数)：true 0：false 1 or 2 左边非零取左边，0 取右边，and相反 身份运算：is is not 判断两个对象是不是为同一个内存地址 成员运算：in not in 判断字符/元素是否在目标中，str，list，dict，set，tuple 位运算： & 与运算 1 1 得1 ， 1 0 得0 ，0 0 得 0 | 或运算 1 1 得1，1 0 得1 ，0 0 得0 方法： int.bit_length() 查看数字在内存中占的字节数 布尔值：True False #不可变数据类型、True为1，False为0 （0，None，False，[],(),{},set(),都为False） 补充： 1、int 转 float 是取整，不是四舍五入 1.1、 int(12.34) --->12 int("12.34") ---> 报错 2、 i = 1， # 注意后面的点 print（type（i））==》(1,) <class 'tuple'>
字符串： str
# 不可变数据类型、有序、可切片，可迭代循环，交互默认输入为字符串 # 以单或双引号表示 ：'元素' # 不可增删改 切片：从左到右字符串中的索引从0开始 [start:end:step] 顾头不顾尾 [1:3] 字符串中索引1到2的字符 [1:-1] -1 表示最后一个字符 操作方法： del str 删除字符串 len(str) 统计字符串长度，内置方法 str.count(元素） 统计字符串中的元素出现的个数 str.center(宽度，"填充物可不写") 指定长度居中显示，默认填充物为空格 str.title() 非字母隔开的单词首字母大写，其余都变小写 china coUntry --> China Country * str.capitalize() 首字母大写，其他单词全部小写 china_Country --> China_country str.swapcase() --->字符串大小写互转 ** str.upper() ----> 全部变成大写 str.isupper() 是否全部为大写 ** str.lower() -----> 全部变成小写 str.islower() 是否全部为小写 str.encoding("将字符串以何种编码集进行编码") ** str.startswith("元素") 判断字符串是否以什么开头，返回bool值 str.endswith("元素") *** str.find("元素"，star，end) 找元素的索引，如果元素不存在，返回-1 *** str.index("元素",star,end) 找元素的索引，如果元素不存在，报错 *** str.strip("元素可空") 去掉两端的 , ,s等空白字符，也可指定字符从两端删 str.lstrip() str.rstrip() ***** str.split("分割符可空，默认空格，多个空格看成一个") 分割字符串，返回列表 str.lsplit() str.rsplit() *** str.replace(old,new,替换几次） *** str.format() 字符串格式化 "{}my name is {}".format(11,"秀*") "{1}my name is {2}，next year is {1}".format(11,"秀*") {id}is old boy ,my name {name}".format(id =11,name="sun") dic = {‘id’：11，‘name’:'sun'} {id}is old boy ,my name {name}".format(**dic) 也可以放字典 % 百分号的方式格式化 "my name is %s ,i am %d" %("sun",30)" "my name is %(name)s ,i am %(age)d" %(dic)" 可以放字典 %s 字符串 %d 整数 %f 小数 %.2f 保留2为小数 3.6以上版本格式话可以：f"{name}已经登录了" str.isalnum() 是否为字母或数字，返回bool值 str.isalpha() 是否全为字母 str.isdigit() 是否全为数字 str.isspace() 是否有空白字符 ***** str.join(iterable可迭代) 字符串拼接,括号里一定得是可迭代得数据，且只能为一个参数 注： "sun".join([11,22]) 报错，join不能将带有数字得list转换成字符串，需要先将数字转换成字符串 "*".join("%s" %id for id in list) object in str 判断元素是否在str中
列表：list
# 可变数据类型，有序，可切片，可迭代循环，元素可为任意类型数据 # 以[元素，]表示 # 可增删改查 切片： 同字符串一样，通过索引切 增： list.append(元素） 向列表末尾添加元素 list.insert(index,元素） 指定索引位置向列表添加元素 list.extend(iterable) 迭代的向列表末尾添加多个元素 删： list.pop(index) 根据索引删除，不添加索引时，默认删除最后一个 list.remove(元素/object） 根据元素删除 del list 删除列表 del list[:3] 根据索引切片删除 list.clear() 清空列表 改： lis[index] = new_data 索引切片修改 lis = [11,22,33,44,55] lis[:2] = [66,77,88] # lis = [66, 77, 88, 33, 44, 55] 步长为1时，不考虑个数对应，切的时一片空间 lis[:3:2] = [66,77] # 报错，步长不为1时，左右元素个数需一致 #ValueError: attempt to assign sequence of size 3 to extended slice of size 2 查： lis[index] 通过索引查 for i in list: 通过迭代循环查，i为列表中的每个元素 方法： del list 删除列表 len(list) 统计列表的长度 list.count(object) 统计列表中指定元素出现的个数 list.index(object,start,end) 查找元素的索引 list.sort(reverse=False) 排序，默认为升序，当reverse值设为True时，降序排列 list.reverse() 列表中元素顺序反转过来 list.copy() 列表浅拷贝 object in list 判断对象是否在列表中
元组：tuple
# 不可变数据类型，有序，可切片，可迭代循环，元素可以是任意数据类型 # 不可增删改 # 以括号表示（） 查： tuple[2] 通过切片查 for i in tuple： 通过迭代循环查 方法： tuple.count(object) tuple.index(object,start,end) len(tuple) object in tuple 元组单个元素，需要在后面加上一个逗号，不然python就不会认为其是一个元组类型 还有 i= 1， python也认为其为一个元组
字典：dict
# 可变数据类型，键值对存在，键不可变,可哈希的（int，str,bool,frozenset)，值可以是任意数据类型，无序，不可切片，可迭代循环查询 # 以大括号表示{key：value} # 可整删查 增： dic = {} dic[new_key] = new_data 直接增加，如果key存在则更新value dic.setdefault(key,value) 本方法一旦key，value都创建，且value指定的不是[]、{}、set(),值都不能更改 new_dic = dict.fromkeys(iterable,values) new_dic = dict.fromkeys([11,22],[33,44]) -->{11: [33, 44], 22: [33, 44]} 前面的key对应相同的value,且当后面的value为可变数据类型时如列表，改变任意一个value， 另一个也会改变，浅拷贝，否则不改变 删： dic.pop(key) 指定key删除，默认删除最后一项,返回删除key对应的value,如果key不存在报错 KeyError: dic.popitem() 随机删除 ，返回删除的键值对以tuple形式显示 3.6以上字典内置为有序，popitem（）默认删除最后一个，但面试要说随机删除 del dic[key] 指定key删除，如果key不存在报错 KeyError: del dic dic.clear() 改： dic[key] = new_data dic.update(dic1) dic将dic1更新到自己的字典中，key重复更新为新value 查： dic[key] key不存在时，报错 dic.get[key,"不存在时自定义返回值"] key不存在时默认返回None，也可自定义返回值 dic.keys() 以仿列表形式存所有key，可迭代 dic.values() dic.items() for i in dic i 为dic的key 方法： len(dic)
集合：set
# 可变数据类型，无序，元素唯一不重复且可哈希即不可变数据类型，可迭代 # 以{}形式表现,主要用于去重 # 不可切片（无序），可增删查 增： set.add(元素) set.update(iterable) 迭代的更新到set中 删： set.pop() 随机删除 set.remove(元素） 没有报错 set.clear() del set 改： 因无序，只能通过先删除后整加的方式 set.remove(待改元素) set.add(新增元素) 查： for i in set: 方法： len(set) 交集： & 相同的部分 并集： | 合体 差集 a-b 去掉在a中b有的元素，减法 s = frozenset([11,22,33]) 将可变数据类型改为不可变
四、 深浅拷贝
浅拷贝：
1、针对的是可变数据类型：list、dict、set ，不可变数据类型int、str、tuple、bool 是没有拷贝一说的，他们都没copy() 方法
2、浅拷贝后是在内存地址中分配了一份新的地址，且浅拷贝只拷贝了第一层，第二层不会拷贝，故第二层如果改变，原数据及浅拷贝后的数据也将改变
3、= 赋值不是浅拷贝，[:] 切片是浅拷贝
a = [11,22,[11,22]]
b = a
注：以上称为赋值，只是将a,b都指向了同一个内存地址
c = a.copy() 用的是list中的方法copy是浅拷贝，id(a) 与 id(c) 的内存地址是不同的
浅拷贝的标准写法为：
import copy
c = copy.copy(a)
3、切片是浅拷贝
切片是浅拷贝的代码演示深拷贝：
就是将原文件内部元素完全拷贝，不会将因为第二层元素改变，另一个也会改变
深拷贝方法：
import copy
list_new = copy.deepcopy()
扩展：枚举函数enumerate(itertable,start)
它返回2个参数，以元组形式返回，一个是可以作为索引，一个是元素
li = [11,22,33,44] for i in enumerate(li): print(i) >>>(0, 11) >>>(1, 22) >>>(2, 33) >>>(3, 44)
扩展:解构,可以通过解构在循环中直接用两个变量接收
for k,v from li: print(k,v)
基础数据类型坑你没商量：
1、range是可迭代对象，可迭代对象都可以进行切片，所有的可变数据类型都有copy方法，但此方法只是对应数据类型写的和浅拷贝类似功能的方法，而真正的浅拷贝都需要导入copy模块。
1 # 2、L = range(100) （4分） 2 L = range(100) 3 # 1) 取第一到第三个元素_______ 4 '''list(L)[:3]''' ===>list(L[:3]) 5 # 2) 取倒数第二个元素_______ 6 '''list(L)[-2]''' ===>L[-2] 7 # 3) 取后十个元素_______ 8 '''list(L)[-10:]'''===>list(L[-10:]) 9 # 4) 把L复制给L1用_______ 10 '''L1 = L.copy()''' 11 error 我做错了 ,结论：可迭代对象都可以切片取值，range类没有copy()方法 12 L1 = L[:] or L1 = L or L1 = copy.copy(L) or L1 = copy.deepcopy()
2、当函数被定义时，Python的默认参数就被创建 一次，而不是每次调用函数的时候创建。 这意味着，如果您使用一个可变默认参数并改变了它，您 将会 在未来所有对此函数的 调用中改变这个对象。
1 # 2、以下的代码的输出将是什么:___(3分) 2 # 3 # def extendList(val,list = []): 4 # list.append(val) 5 # return list 6 7 # list1 = extendList(10) = list 8 # list2 = extendList(123, []) 9 # list3 = extendList(‘a’) 10 11 # print “list1 = % s” % list1 12 # print “list2 = % s” % list2 13 # print “list3 = % s” % list3 14 15 answer: 16 list1 = [10,a] 17 18 list2 = [123] 19 20 list3 = [10,a]
- 打印进度条
import time for i in range(0,101,2): time.sleep(0.1) char_num = i//2 #打印多少个'*' per_str = ' %s%% : %s ' % (i, '*' * char_num) if i == 100 else ' %s%% : %s'%(i,'*'*char_num) print(per_str,end='', flush=True)