ONE
1.pyhon 解释型,弱类型,语言.
优点: 有良好的平台兼容性,在任何环境中都可以运行,前提是安装了解释器,灵活.修改代码的时候直接修改就可以,可以快速部署,不用停机维护.
可移植性,可嵌入性,可扩展性,
缺点: 每次运行的时候都要解释一遍,性能上不如编译型语言.
速度慢,代码不能加密,线程不能利用多cpu问题.
2.python解释器.
CPython 使用最广泛的python解释器.
IPython.
PyPy ,它的目标就是执行速度,
JPython
IronPython
3.变量,
变量: 将运算的中间结果暂时存到内存,以便后续程序调用.
变量的命名规则:
1. 变量由字母,下划线,数字搭配而成,
2.不可以用数字开头,更不能用纯数字.
3.不能是python的关键字,这些符号和字母已经被python占用,不可以更改.
4.不要用中文,
5,名字要有意义,
6.区分大小写,
7.建议使用驼峰体,或下划线,
8.不要太长,
驼峰体: 除首字母外的其他每个单词 首字母大写.
下划线: 每个单词之间用下划线分开.
4. 常量
在python中不存在绝对的常量,约定俗成,所有字母大写就是常量.
例如: PI =3.1415926
CHANGJING_OF_SUNLI = 1314
5.注释.
有时候我们写的东西不一定都是给用户看的,或者不希望解释器执行.那我们可以使用 # 注释掉代码,被注释的东西是不会被执行的,可以方便后面的程序员来拜读你的代码.
单行注释: # 被注释的内容.
多行注释: ''' 被注释的内容''' """ 这个也是多行注释"""
6. python的基本数据类型
1,整数(int)
常见的数字都是int类型.用于计算或者大小的比较,
2.字符串(str)
在python中,凡是用引号引起来的,全是字符串.
字符串可以用单引号,双引号,或者三引号来引起来,没有什么区别,
3. 布尔值(bool)
真或者假, True 和 False
7. 用户交互
使用input()函数,可以让我们和计算机互动起来.
语法:
内容 = input(提示信息)
8. 流程控制if语句,
1.第一种语法:
if 条件: # 引号是将条件与结果分开
结果1. #四个空格,或者一个tab键,这是告诉程序满足这个条件的.
结果 2
如果条件是真(True)执行结果1,然后结果2,如果条件是假(False)直接结果2
2. 第二种语法:
if 条件:
结果1
else:
结果2
代码3
3.第三种语法:
if 条件1:
结果1
elif 条件2:
结果2
.....
else:
结果n
4.第四种语法(嵌套);
if 条件1:
结果1
if 条件2:
结果2
else:
结果3
else:
结果4
# 可以无限的嵌套,但是在实际开发中,尽量不要超过三层嵌套.
9. 流程控制-while循环
while 条件:
结果
# 如果条件是真,则执行结果,然后再次判断条件,知道条件是假,停止循环.
# 怎么才能结束循环? 1.改变循环条件 2,break
10. 流程控制 break 和 continue
1, break : 立刻跳出循环体,打断的意思.
2. continue : 停止本次循环,继续执行下一次循环.
TWO --- 运算符和编码
1. 格式化输出
name = input("Name:") age = input("Age:") job = input("Job:") hobby = input("Hobbie:") info = ''' ------------ info of %s ----------- #这⾥里里的每个%s就是⼀一个占位符，本⾏行行的代表 后⾯面拓拓号⾥里里 name Name : %s #代表 name Age : %s #代表 age job : %s #代表 job Hobbie: %s #代表 hobbie ------------- end ---------------- ''' % (name,name,age,job,hobbie) # 这⾏行行的 % 号就是 把前⾯面的字符串串 与拓拓号 后⾯面的 变量量 关联起来 print(info)
%s 就是字符串占位符, 除此之外,还有%d,是数字占位符.
使用时,需要进行类型转换,
int(str) # 字符串转换成int
str(int) # int转换成字符串
2.基本运算符
算数运算,
比较运算
逻辑运算
赋值运算,
成员运算
身份运算
位运算
逻辑运算:
and 布尔'与', 如果x为False, x and y 返回False,否则它返回y的计算值.
or 布尔'或',如果x为True, 它返回True,否则它返回y的计算值.
not 布尔"非",如果x为True,返回False,如果x为False,返回True
针对逻辑运算的进一步研究:
1.在没有()的情况下not优先级高与and,and优先级高与or,
优先级关系为: () > not > and > or
2, x or y, x为真,值就是x. x为假,值是y
and 是or的相反.
3.编码的问题
ASICC码, 8个bit 1个byte
GBK 国标码 16个bit 2个byte
UNICODE 万国码 32个bit 4个byte
UTF -8 可变长度的unicode
英文 8个bit 1个byte
欧洲文 16个bit 2个byte
中文 24个bit 3个byte
补充 1 , while 循环
while 条件:
循环体
else: 循环在正常情况跳出之后会执行这里.
index = 1 while index < 11: if index == 8:
# break pass else: print(index) index += 1 else: print("hello")
注意, 如果循环是通过break退出的,那么while后面的else将不会被执行,只有while条件判断是假的时候,才会执行else
pass :不表示任何内容,为了代码的完整性,占位而已.
补充 2 : in 和 not in
可以判断xxx字符串是否出现在xxxxxx字符串中.
content = input("请输入你的评论:") if '苍老师' in content or '麻花藤' in content: print("你输入的内容不合法.") else: print("评论成功.")
THREE --- 基本数据类型(int,str,bool)
1.python基本数据类型,
1, int => 整数,主要用来进行数学运算.
2, str => 字符串,可以保存少量数据并进行相应的操作.
3, bool => 判断真假, True ,False
4, list => 存储大量数据,用 [ ]表示
5, tuple => 元组,不可以发生改变,用( )表示.
6, dict => 字典,保存键值对,一样可以保存大量数据,
7, set = > 集合, 保存大量数据,不可以重复,其实就是不保存value的dict
2 . 整数(int)
在python3中所有的整数都是int类型,在python2中如果数据量较大,会使用long类型.
整数可以进行的操作:
bit_length() 计算整数在内存中国占用的二进制的长度
3.布尔值(bool)
取值只有True,False. bool值没有操作,
转换问题:
str => int int(str)
int => str str(int)
int => bool bool(int) 0是False,非0是True
bool => int int(bool) True是1,False是0
str => bool bool(str) 空字符串是False,不空是True
bool =>str str(bool) 把bool值转换成想用的值.
4, 字符串(str)
把字符连成串,在python中用', "", """,引起来的内容被称为字符串.
4,1 切片和索引.
1.索引,索引就是下标,切记,下标从0开始.
s = 'python吧啦哈' print(s[0]) # 获取第0个 print(s[1]) #print(s[9]) #没有第9个,越界了,会报错. print(s[-1]) # -1, 表示倒数 print(s[-2]) # 倒数第二个
2. 切片. 我们可以使用下标来截取部分字符串的内容
语法 : str [start : end]
规则: 顾首不顾尾,从start开始截取,截取到end位置,但是不包括end
s2 = 'python巴拉哈' print(s2[0:3]) # 从0截取到3,不包含3,结果是pyt print(s2[6:8]) # 结果 拉哈 print(s2[6:9]) # 最大是8,但是根据顾首不顾尾,想要取到8必须给9 print(s2[6:10]) #如果右边已经过了最大值,相当于截取到最后. print(s2[4:]) # 如果想要截取到最后,那么最后一个值可以不给, print(s2[-1:-5]) #从-1获取到-5 这样是获取不到任何结果的,想要倒序着获取,必须后面加个-1的步长 print(s2[-1:-5:-1]) #这样便是从后往前开始获取.
步长: 如果是整数,则从左往右取,如果是负数,则从右往往左取.
切片语法: str [start:end:step]
4.2 字符串的相关操作方法.
切记,字符串是不可变的对象,所有任何操作对原字符串是不会有任何影响的.
1.大小写转来转去,
s1 = 'changjing' s1.capitalize() print(s1) #输出发现并么用任何的变化,因为这里的字符串本身是不会改变的,需要我们重新获取. ret1 = s1.capitalize() print(ret1) # 大小写的转换 ret = s1.lower() #全部转换成小写 print(ret) ret = s1.upper() # 全部转换成大写 print(ret) ret = s1.swapcase() # 大小写互相转换 print(ret) # 不常用 ret = s1.casefold() # 转换成小写,和lower的区别:lower()对某些字符支持不够好,casefold()对所有的字母都有效,比如东欧的一些字母. print(ret) # 每个被特殊字符隔开的字母首字母都大写. s3 = 'alex eggon, taibai*yiew_笨蛋' ret = s3.title() print(ret) # 中文也算是特殊字符 s4 = 'alex老男孩wusir' print(s4.title())
2.切来切去
# 居中 s5 = '周杰伦' ret = s5.center(10,'*') # 拉长成10,把原字符串放中间,其余位置补 print(ret) #更改tab的长度 s6 = 'alex wusir eggon' print(s6) print(s6.expandtabs()) #可以改变 的长度,默认长度更改为8 # 去空格 s7 = ' alex wusri ' ret = s7.strip() # 去掉左右两端的空格 print(ret) # s7.lstrip() 是去掉左边的空格 s7.rstrip()是去掉右边的空格 s7 = 'adadwq' print(s7.strip('ada')) # 也可以指定去掉的元素. # 字符串替换 s8 = 'alex_bendan_wusir_taibai_hha' ret = s8.replace('wusir','shazi') # 把wusir替换成shazi print(ret) # 切记 ,! 字符串是不可变对象,所有操作都是产生新字符串返回 ret = s8.replace('i','sb',2) # 把替换成sb,替换2个 print(ret) # 字符串切割 s9 = 'alex,wusir,bendan,taibai,haha' lst = s9.split(",") # 字符串切割,用','进行切割 print(lst) # 还可以用 进行切割 # 坑 s10 = '哈哈笨蛋哈哈傻子哈' lst = s10.split('哈') # 如果切割符在左右两端,那么一定会出现空字符串, 深坑请留意. print(lst)
3.格式化输出
# 格式化输出 s12 = '我叫%s,今年%d岁了,我喜欢%s' % ('笨蛋','18','哈哈') # 之前的写法. print(s12) s12 = '我叫{},我今年{}岁了,我喜欢{}'.format('笨蛋',18,哈哈) #按位置格式化 print(s12) s12 = '我叫{0},我今年{2}岁了,我喜欢{1}'.format('笨蛋','哈哈',18) # 按指定位置 print(s12) s12 = '我叫{name},我今年{age}岁了,我喜欢{hobby}'.format(name='笨蛋',age=18,hobby='哈哈') # 指定关键字 print(s12)
4.查找
s13 = '我叫笨蛋,我喜欢你,你喜欢我吗' ret1 = s13.startswith('我叫') # 判断是否以我叫开头 print(ret1) ret2 = s13.startswith('笨蛋') # 判断是否以笨蛋开头 ret3 = s13.endswith('我吗') # 判断是否以我吗结尾 print(ret3) ret4 = s13.count('你') # 查找'你'出现的次数 print(ret4) ret5 = s13.find('蛋') # 查找'蛋'出现的位置 print(ret5) ret6 = s13.find('哈哈') # 查找'哈哈'出现的位置,如果没有返回 -1 print(ret6) ret7 = s13.find('喜欢',2,8) # 切片找. print(ret7) ret8 = s13.index('笨蛋') # 求索引的位置,注意如果找不到索引,程序会报错. print(ret8)
5.条件判断
# 条件判断 s14 = '123.16' s15 = 'abc' s16 = '_abc!21' # 是否由字母和数字组成. print(s14.isalnum()) # 是否由字母组成 print(s14.isalpha()) # 是否由数字组成,不包括小数点. print(s14.isdigit())
6. 计算字符串的长度
s18 = '我是你心目中的小太阳.哈哈哈' ret = len(s18) # 计算字符串的长度 print(len(ret))
# 注意 : len()是python的内置函数,所以访问方式也不一样,你就记着len()和print()一样就行了.
7.迭代
我们可以使用for循环来便利(获取)字符串中的每一个字符.
语法:
for 变量 in 可迭代对象:
pass
可迭代对象: 可以一个一个往外取值的对象
s19 = '大家好,我是vue,前端的小朋友,你们好么?' # 用while循环 index = 0 while index < len(s19): print(s19[index]) # 利用索引切片来完成字符的查找 index += 1 # for 循环,把s19中的每个字符拿出来赋值给前面的c for c in s19: print(c) ''' in 有两种用法: 1,在for中,是把每个元素获取到赋值给前面的变量. 2, 不在for中,判断是否出现在str中. ''' print('vue' in s19)
FOUR --- 基本数据类型(list, tuple)
1.列表
1.1 列表的介绍,
列表是python的基础类型之一,其他编程语言也有类似的数据类型,比如JS中的数组,java中的数组,它是以 [ ]括起来的,每个元素用' , ' 逗号隔开而且可以存放各种数据类型.
2.2 列表的索引和切片
列表和字符串一样也拥有索引,
lst = ['麻花藤','王建淋','马芸','哈哈哈','大笨蛋'] print(lst[0]) #获取第一个元素 lst[3] = 'zz' # 注意,列表是可以发生改变的,这里和字符串不一样. print(lst) s0 = '哈哈哈' s0[1] = '嘿' # Typeerror: 'str' boject does not support item assignment 不准许改变 print(s0)
列表的切片:
lst = ["麻花藤", "王剑林林", "⻢马芸", "周鸿医", "向华强"] print(lst[0:3]) # ['麻花藤', '王剑林林', '⻢马芸'] print(lst[:3]) # ['麻花藤', '王剑林林', '⻢马芸'] print(lst[1::2]) # ['王剑林林', '周鸿医'] 也有步⻓ print(lst[2::-1]) # ['⻢马芸', '王剑林林', '麻花藤'] 也可以倒着取 print(lst[-1:-3:-2]) # 倒着带步长
2. 列表的增删改查
1, 增 append,insert , extend
注意,list和str是不一样的,lst可以发生改变,所以直接就在原来的对象上进行操作.
lst = ['麻花藤','卢本伟','哈哈哈','大傻子'] print(lst) lst.append('大笨蛋') print(lst) lst = [] while True: content = input("请你输入你要输入的员工信息,输入Q退出:") if content.upper == "Q": break lst.append(content) print(lst) lst = ['麻花藤','大笨蛋','嘿嘿嘿'] lst.insert(1,'刘德华') # 在1的位置插入刘德华,原来的元素向后移动一位. print(lst) # 迭代添加 lst =['啦啦啦','叭叭叭','嘿嘿嘿'] lst.extend(['哎哟哟','麻花好吃']) print(lst)
2.删
pop,remove ,del ,clear
lst = ['笨蛋','烧鸡','麻辣小龙虾','山竹'] print(lst) deleted = lst.pop() # 默认删除最后一个. print("被删除的",deleted) # 返回被删除的值 print(lst) el = lst.pop(2) # 删除2号元素 print(el) print(lst) lst.remove('笨蛋') # 删除指定元素 print(lst) # lst.remove('飒飒') # 删除不存在的元素会报错 # print(lst) lst.clear() # 清空列表 print(lst) # 切片删除 del lst[1:3] print(lst)
3.修改
索引切片修改
# 修改 lst =['太白','太黑','太啊','哈哈'] lst[1] = '太污' #把1号元素修改成太污 print(lst) lst[1:4:3] = ['大笨蛋','啥玩意'] # 切片修改也ok,如果步长不是1,要注意,元素的个数 print(lst) lst[1:4] = ['你是个大笨蛋'] # 如果切片没有步长或者步长是1,则不用关心个数.因为默认步长就是1 print(lst)
4.查询. 列表是一个可迭代对象,所以可以进行for循环
for el in lst: print(el)
5. 其他操作
lst = ['太白','太嘿','太笨','太蓝','太穷'] c = lst.count('太白') # 查询'太白'出现的次数 print(c) lst = [1,11,3,22] lst.sort() # 排序,默认升序 print(lst) lst.sort(reverse = True) #降序 print(lst) # 翻转 lst.reverse() print(lst) l = len(lst) # 列表的长度 print(l)
3. 列表的嵌套
采用降维操作,一层一层的看就好.
lst = [1,'太白','wusir',['吗哈哈',['可口可乐'],'巴啦啦能量']] # 找到wusir print(lst[2]) # 找到太白的白字 print(lst[1][1]) # 将wusri找到,然后将首字母大写,再仍回去 s = lst[2] s = s.capitalize() lst[2] = s print(lst) # 简写 lst[2] = lst[2].capitalize() print(lst) # 把太白换成太黑 lst[1] = lst[1].replace('白','黑') print(lst) # 把吗哈哈换成吗笨哈 lst[3][0] = lst[3][0].replace('哈','笨') print(lst[3][0]) lst[3][1].append('雪碧') print(lst)
4. 元组和元组嵌套
元组: 俗称不可变的列表,又被称为只读列表.
元组也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据.,查询可以,循环可以,切片也可以,但就是不能改.
tu = (1,'太白','李白','太黑','哈哈') print(tu) print(tu[0]) print(tu[2:5]) # 切片之后还是元组 # for循环遍历元组 for el in tu: print(el) # 尝试修改元组 # tu[1] = '太黑' # 报错,'tuple' boject does not support item assigment tu = (1,'哈哈',[],'啊啊') # tu[2] = 'asdas' # 这么改不行 tu[2].append('大笨蛋') # 可以改了,没报错. tu[2].append('阿拉蕾') print(tu)
关于不可变,注意: 这里元组的不可变的意思是子元素不可变,而子元素内部的子元素是可以变的,这取决于子元素是否是可变对象.
元组中如果只有一个元素,一定要添加一个逗号,否则就不是元组.
tu = (1, ) print(type(tu))
元组也有count(), index(),len() 等方法,可以自己测试使用.
5.range
range可以帮我们获取到一组数据,通过for循环能够获取到这些数据.
for num in range(10): print(num) for num in range(1,10,2): print(num) for num in range(10,1,-2) #反着来,和切片一样. print(num)
FIVE --- 基本数据类型(dict)
1.字典的简单介绍
字典(dict)是python中的唯一的一个映射类型,它是以{ } 括起来的键值对组成.
在dict中key是唯一的,在保存的时候,根据key来计算出一个内存地址,然后将key-value保存在这个地址中,这种算法称为hash算法,所以,切记,在dict中存储的kkey-value中的key必须是可hash的,如果搞不懂什么是可哈希,暂时可以这样记,可以改变的都是不可哈希的.
可哈希数据类型(不可变):int,str,tuple,bool
不可哈希数据类型(可变):list,dict,set
语法: {key1:value1,key2:value2....}
注意: key必须是不可变(可哈希的),value没有要求,可以保存任何数据类型的数据,
# 合法 dic = {123:456,True:999,'id': 1, 'name':'bendan','age':18,'stu':['哈哈','傻紫'],(1,2,3):'笨蛋'} print(dic[123]) print(dic[True]) print(dic['id']) # 不合法 #dic = {[1,2,3]:'周杰伦'} #list是可变的,不能作为key #dic = {[1:2],'啦啦啦'} # dict是可变的,不能作为key #dic = {{1,2,3}:'呵呵呵'} #set是可变的,不能作为key
dict保存的数据不是按照我们添加进去的顺序保存的,是按照hash表的顺序保存的,而hash表不是连续的,所以不能进行切片工作,它只能通过key来获取dict中的数据.
2.字典的增添改查和其他相关操作
1,增加
dic = {} dic['name'] = '周润发' #如果dict中没有出现这个key,就会新增一个key-value的组合进dict dic['age'] = 18 print(dic) # 如果dict中没有出现过这个key-value,可以通过setdefault设置默认值 dic.setdefault("李嘉诚") # 也可以往里面设置值 dic.setdefault("李嘉诚",'房地产') # 如果dict中已经存在了,那么setdefault将不会起作用. print(dic)
2,删除
ret = dic.pop('jay') print(ret) del dic['jay'] print(dic) # 随机删除 ret = dic.popitem() # 清空字典中的所有内容 dic.clear()
3.修改
dic = {'id':123,'name':'sylar','age':18}
dic1 = {'id':456,'name':'麻花藤','ok':'wtf'}
dic.update(dic1) # 把dic1中的内容更新到dic中,如果key重名,则修改替换,如果不存在key,则新增.
print(dic)
print(dic1)
4.查询
查询一般用key来查找具体的数据.
print(dic['name']) # print(dic['sylar']) #报错 print(dic.get('ok')) print(dic.get('sylar')) #None print(dic.get('sylar','牛b')) # 牛b
5.其他相关操作
dic = {'id':123,'name':'sylar','age':18,'ok':'科比'}
print(dic.keys()) #dict_key(['id','name','age','ok'])不用管它是什么,当成list来用就行.
for key in dic.keys():
print(key)
print(dic.value()) #dic_values([123,'sylar',18,'科比']) 一样,当list来用
for value in dic.values():
print(value)
print(dic.items()) # dic_items([('id',123),('name','sylar'),('age',18),('ok','科比')]) 这个东西也是list,只不过list中装的是tuple
for key,value in dic.items(): # 这个是解构
print(key,value)
#解构
a,b = 1,2
print(a,b)
(c,d) = 3,4
print(c,d)
e,f = [1,2,3] #解构的时候注意数量必须匹配
print(e,f)
3. 字典的嵌套
# 字典的嵌套 dic1 = { "name":"汪峰", "age":18, "wife":{ "name":"章子怡", "age":28 }, "children":['第一个毛孩子 ','第二个毛孩子'], "desc":"峰哥不会告诉我吧,没关系,我想上头条." } print(dic1.get('wife').get('name')) print(dic1.get('children')) print(dic1.get('children')[1])
6.SIX
1. is 和 == 的区别
# 小数据池
# 数字小数据池的范围 -5 ~ 256
# 字符串如果有特殊字符他们的内存地址就不一样.
# 字符串中单个*20以内他们的内存地址一样,单个*20以上内存地址不一样
# a = 'alex@' # a1 = 'alex@' # print(a is a1) # Fales # n = 5//2 # n1 = 2 # print(n is n1) #True # a = 'a'*21 # b = 'a'*21 # print(a is b) # a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' # b = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' # print(a is b) # n = -6 # n1 = -6 # print(n is n1) #False # n = -5 # n1 = -5 # print(n is n1) #True # n = 257 # n1 = 257 # print(n is n1) #True
总结 :
== 比较, 比较的两边的值
is 比较, 比较的是内存地址 id()
2.编码和解码
encode(编码方式) --- 拿到明文编码后对应的字节
decode(编剧方式) --- 将编码后的字节解码成对应的明文
# 注意: 用什么进行编码就要用什么进行解码,
SEVEN --- set集合,深浅拷贝,以及部分知识点补充
1.基础数据类型补充
li = ['拉拉啦','哈哈哈','大恩但','呃呃呃'] s = "_".join(li) print(s) li = ['黄花大闺女'] s = "_".join(li) print(s)
列表:
循环删除列表中的每一个元素
li = [11,22,33,44] for el in li: print(el) print(li) #结果:[22,44]
分析原因:
for的运行过程,会有一个指针来记录当前循环的元素是哪一个,一开始这个指针指向第0个,然后获取到第0个元素,紧接着删除第0个,这个时候,原来是第一个的元素会自动的变成第0个,然后指针向后移动一次,指向1元素,这时候原来的1已经变成了0,也就不会被删除了.
用pop删除试试看:
li = [11,22,33,44] for i in range(0,len(li)): del li[i] print(li) #结果:报错 # i = 0,1,2 删除的时候li[0] 被删除之后,后面一个就变成了 第0个 # 以此类推,当i = 2的时候,list中只有一个元素,但是这个时候删除的是第2个.所有报错
经过分析发现,循环删除都不行,不论是用del还是用remove.都不能实现,那么pop呢?
for el in li: li.pop() # pop也不行, print(li) # 结果:[11,22]
只有这样是可以的:
for i in range(0,len(li)): # 循环len(li)次,然后从后往前删除 li.pop() print(li)
或者,用另一个列表来记录你要删除的内容,然后循环删除.
li = [11,22,33,44] del_li = [] for e in li: del_li.append(e) for e in del_li: li.remove(e) print(li)
注意: 由于删除元素会导致元素的索引改变,所有容易出现问题,尽量不要再循环中直接去删除元素,可以把要删除的元素添加到另一个集合中然后再批量删除.
dict中的fromkeys(),可以帮我们通过list来创建一个dict
dic = dict.fromkeys(['jay','jj'],['bendan','lal']) print(dic) # 结果:{'jay':['bendan','lal'],'jj':['bendan','lal']}
前面列表中的每一项都会作为key,后面列表中的内容作为value,生成dict.
dic = dict.fromkeys(['jay','jj'],['哈哈','嘿嘿']) print(dic) dic.get('jay').append('哼哈') print(dic) # 结果:{'jay':['哈哈','嘿嘿','哼哈'],'jj':['哈哈','嘿嘿','哼哈']}
代码中只是更改了jay那个列表,但是由于jay和jj用的是同一个列表,所以,前面那个改了,后面那个也会跟着改.
dict中的元素在迭代过程中是不允许进行删除的
dic = {'k1':'alex','k2':'wusir','s1':'金老板'}
# 删除key中带有'k'的元素
for k in dic:
if 'k' in k:
del dic[k] # 在循环迭代的时候不允许进行删除操作
print(dic)
把要删除的元素暂时先保存在一个list中,然后循环list,再循环.
dic = {'k1':'alex','k2':'wusir','s1':'金老板'}
li = []
# 删除key中带有'K'的元素
for k in dic:
if 'k' in k:
li.append(k)
for el in li:
del dic[el]
print(dic)
类型转换:
元组 => 列表 list(tuple)
列表 => 元组 tuple(list)
list => str str.join(list)
str => list str.split()
转换成False的数据
0 , '' , None , [] , {}, set()==> False
2. set集合
set集合是python的一个基本数据类型,一般不是很常用,set中的元素是不重复的,无序的,里面的元素必须是可hash的(int,str,tuple,bool),我们可以这样来记,set就是dict类型的数据但是不保存value,只保存key,set也用{ } 表示.
注意:set集合中的元素必须就可hash的,但是set本身是不可hash的,set是可变的.
set1 = {'1','alex',2,True,[1,2,3]} #报错
set2 = {'1','alex',2,True,[1,2]} #报错
set中的元素是不重复的,且无序的.
s = {'哈哈','呵呵黑','哈哈'}
print(s)
#结果: {'哈哈','呵呵黑'}
使用这个特性,我们可以使用set来去掉重复
# 给list去重复 lst = [45,5,'哈哈',45,'哈哈',50] lst = list(set(lst)) # 把list转换成set,然后再转回list print(lst)
set集合增删改查
1.增加
s = {'啦啦啦','bane','啥呀'}
s.add('嗯嗯')
print(s)
s.add('嗯嗯') # 重复的内容不会添加到set集合中
print(s)
s = {'啦啦啦','bane','啥呀'}
s.update('是的吗') # 迭代更新
print(s)
s.update(['张曼玉','李若彤','李若彤'])
print(s)
2.删除
s = {'啦啦啦','bane','啥呀','吴秀波'}
item = s.pop() #随机弹出一个
print(s)
print(item)
s.remove('啥呀') # 直接 删除元素
# s.remove("苏大") # 不存在这个元素,删除会报错
print(s)
s.clear() # 清空set集合,需要注意的是set集合如果是空的,打印出来是set()因为要和dict区分的.
print(s) # set()
3.修改
# set集合中的数据没有索引,也没有办法去定位一个元素,所以没有办法进行直接修改 # 我们可以采用先删除再添加的方式来完成修改操作 s = {'啦啦啦','bane','啥呀'} s.remove('啥呀') s.add('赵本山') print(s)
4.查询
# set是一个可迭代对象,所有可以进行for循环 for el in s: print(el)
5.常用操作
s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
# 交集
# 两个集合中的共有元素
print(s1 & s2) # {'皮长山'}
print(s1.intersection(s2))
# {'皮长山'}
# 并集
print(s1 | s2) # {'刘科长', '冯⻓长', '赵四', '皮长山', '刘能'} print(s1.union(s2)) # {'刘科长', '冯乡⻓长', '赵四', '皮长山', '刘能'}
# 差集
print(s1 - s2) # {'赵四', '刘能'} 得到第⼀一个中单独存在的 print(s1.difference(s2)) # {'赵四', '刘能'}
# 反交集
print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡长', '刘能', '刘科长', '赵四'}
print(s1.symmetric_difference(s2)) # {'冯乡长', '刘能', '刘科长', '赵四'}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "皮长山"} # ⼦子集
print(s1 < s2) # set1是set2的⼦子集吗? True print(s1.issubset(s2))
# 超集
print(s1 > s2) # set1是set2的超集吗? False print(s1.issuperset(s2))
set集合本身是可以发生改变的,是不可hash的,我们可以使用frozenset来保存数据.
frozenset是不可变的,也就是一个可哈希的数据类型.
s = forzenset(['笨蛋','哈哈','旺旺']) dic = {s:'123'} # 可以正常使用了. print(dic) # 结果是: {forzenset({'笨蛋','哈哈','旺旺'}):'123'}
3. 深浅拷贝
赋值 :
对于list,set,dict来说,直接赋值其实是把内存地址交给变量,并不是复制一份内容,所以,lst1的内存指向和lst2是一样的,lst1改变了,lst2也发生了改变.
浅拷贝:
两个lst完全不一样,内存地址和内容也不一样,发现实现了内存的拷贝.
结果: 只会拷贝第一层,第二层的内容不会拷贝,所以被称为浅拷贝.
[ : ]或者copy()
深拷贝:
深度拷贝,把元素内部的元素完全进行拷贝复制,不会产生一个改变另一个跟着改变的问题.
deepcopy