昨晚把雨伞放在实验室了 ，所以今早跟室友一起打伞来的
------- 到达实验室 08：10晚了一些吗，又刚刚复习完做昨天的学习1笔记 ------
现在是北京时间 08：41 ------开始学习-------
1.字典的特点：
1.1 key不允许重复
举个例子：
d = {'name':"张三",'name':'李四'}
print(d)
从程序中可以看出，相同的key值，取得是最后一个key为主。
1.1.2 Value可以重复
比如
d = {'name':"张三",'names':'张三'}
print(d)
你看都可以输入张三的value。
1.1.3是不可变序列
意思是不可以插入。
d = {'name':"张三",'names':'张三'}
print(d)
lst=[10,20,30]
lst.insert(1,100)
print(lst)
d={lst:100}
print(d)
标红色的可以插入，但是list是一个可变的对象，是不可以计算hash值的。所以最后两行代码运行就会报错。
字典也是一个可变对象，只不过对里面的内容必须是不可变的，包括str和int
这里还需要说一下：字典的结构是需要计算hash值的，所以第一个值和第二个值离得会很远，会有很多空缺，造成一定的空间浪费，但是字典的查找速度还是很快的。
1.2字典生成式：
内置函数zip()
语法结构：
keys=[]
values=[]
{ x:y for x,y in zip(keys,values) }
例如：
item=['Fruit','BOOK','Other']
prices=[98,85,66]
d= {x:y for x ,y in zip(item,prices)}
print(d)
一一对应
但是你看key既有大写，还有小写 想要统一化。
那就是 { x.upper() :y for x,y in zip(keys,values) }
标红的这里是我后加上去的，就会统一化。
但是大家有没有想过。加入这俩key和values数量不等怎么办？
那就是以少数的那个为准。
例如：
item=['Fruit','BOOK','Other']
prices=[98,85,66,84,69]
d= {x:y for x ,y in zip(item,prices)}
print(d)
结果一目了然。
总结一下：
字典的创建：1.使用{}花括号。2.内置函数dict()3.字典生成式
常用操作:获取value:1.字典名[key] 2.字典名+.+get(key)
删除key-value:1. del字典名[key]
修改/新增：字典名[key]=value
判断：in / not in
2.元组
是一个不可变序列，是python内置的数据结构之一
这里来总结下序列的两种分类：
不可变序列;str和元组：没有增删改操作的，对象地址发生改变
可变序列：列表和字典，可进行增删改，对象地址不发生更改
形式如： t = ('python','hello',90)
从外观角度而言，元组和列表只差在一个括号上
2.2元组的创建方式
1.直接小括号
t = ('python','hello',90)
2.使用内置函数
t = tuple(('python','hello',90)
3.只包含一个元组的元素需要使用逗号和小括号
t=(10,)
我把这三种方式整理了下：
d = ('python','hello',98)
print(d)
print(type(d))
d= 'python','hello'
print(d)
print(type(d))
d1=tuple(('python','hello',98))
print(d1)
d2=('python')
print(d2)
print(type(d2))
d3=('pythpn',)
print(d3)
print(type(d3))
其中有一个是不需要+()的。也可以，以及单个元素记得+，
这里还有空元组
我们再回顾一下空列表、空字典创建方式‘
lst=[]
lst1=list()
lst=[]
lst1=list()
d={}
d1=dict()
t=()
t1=tuple()
print('空列表',lst,lst1,'空字典',d,d1,'空元组',t,t1)
2.3关于元组设计成不可变序列：
元组只能让人看，不能修改，所以不需要上锁。
而像列表、字典能修改，可是得加锁，进一个人就上锁，其他人必须排队。
但是元组中会有列表这等元素，不能修改，但可以增删。
比如：
t = (10,[20,30,40],50) print(t) print(type(t)) print(t[0]) print(t[1]) print(t[2]) t[1].append(100) print(t[1]) t[1].remove(20) print(t[1])
需要注意的是，索引它的位置就是：元组名+[索引的位置]。方括号
2.4 元组的遍历
元组是可迭代对象，可以使用for...in...来遍历
其中语法结构 for+你要设定的变量名+in+元组名，还要记得缩进哈
t= tuple(('python','hello',99))
for x in t:
print(x)
意外的是：
t= tuple(('python','hello',99))
for x in t:
print(x)
print(t[1])
print([t[1]])
---中午吃了昨天剩下的铁锅炖 现在是北京时间12：46 ，准备稍微休息一下，开始学习。----
醒来--13：26开始学习：
3.集合
3.1特点：
1.集合是没有value的字典
2.与列表，字典一样的可变类型序列（可增删减）
3.内置数据结构
3.2创建
3.2.1直接方式：{}
s={'python',hello',98}
2.使用内置函数 set()
s={'python','shw',99}
print(s)
print(type(s))
这里切记一点不可重复。
s={'python','shw',99,99,99}
print(s)
print(type(s))
看到没？而且顺序还变了。
3.2.2使用内置函数set()
x=set(range(6)) print(x,type(x))
3.3集合转化类型
列表转换、元组转换、字符串转换、空集合
s1=set([1,2,3,4,55,55,66,66])
print(s1,type(s1))
s2=set((1,2,3,'hello'))
print(s2,type(s2))
s3=set({1,2,3,})
print(s3,type(s3))
s4=set('python') 可从程序中看出来是无序的
print(s4,type(s4))
s5=set()
print(s5,type(s5))
3.2相关操作（增删改）
3.2.1.判断操作
in 与 not in
s=set([1,2,3,4,55,55,66,66]) print(98 in s) print(66 in s) print(66 not in s)
3.2.2新增操作
add()：一次添中一个元素
s.add(98) print(s)
update():至少添加一个元素
s.update({55,66}) 增加字典
print(s)
s.update([98,'hello']) 增加列表
print(s)
s.update((52,'hello','python')) 增加元组
print(s)
3.2.3删除操作
remove() ：一次删除一个指定元素，如果指定元素不存在，报KeyError
s.remove(2) print(s)
discard():一次删除一个指定元素，如果指定元素不存在，不报出异常
s.discard(66) 有错误也不会报出
print(s)
s.discard(500)
print(s)
pop():一次只删除一个任意元素
s.pop()
print(s) 不可以指定
clear():清空集合
s.clear() print(s)
空集合
运行代码如图所示：
3.3集合相等
1.符号“==”，以及！= 来表示
print(s2 == s3) print(s2 !=s3)
2.一个集合是另一个集合的子集，使用issubset()来判断
print(s2.issubset(s)) print(s3.issubset(s))
3.一个集合是另外一个集合的超集 使用issuperset()
print(s2.issuperset(s))
4.没有交集 使用isdisjoint来判断
print((s2.isdisjoint(s3))) 有交集为False，无交集为True
程序如图：
3.4集合的数学操作
3.4.1交集 intersection or &
print(s1.intersection(s2)) print(s1 & s2)
3.4.2并集
符号：union or |
print(s.union(s2)) print(s | s2)
3.4.3差集与对称差集
s=set([1,2,3,4,55,55,66,66])
s2={1,2,3}
s3={2,65,85}
print(s.intersection(s2))
print(s & s2)
print(s.union(s2))
print(s | s2)
print(s2.difference(s)) 这个是s2扣除s集合交集后剩的集合
print(s2 - s)
print(s.symmetric_difference(s2)) 扣除两个集合交集之后的剩余集合
print(s ^ s2)
3.4集合生成式
语法结构：{ i*i for i in range(1,10)}
将{} 变为[]就是集合生成式 ，没有元组生成式
集合特点就是无序的 集合元素结果也是不重复的
4.字符串的创建与驻留机制
不可变的字符序列和元组一样
单引号 双引号 三引号定义字符串都可以，id都是一个
1.字符串长度为0或者1 即空字符串或者为一个长度的字符串 比如a 和''
2.标识符：字母 数字 下划线 id都是一个
3.[-5，256]之间的整数数字
4.编译时驻留
注意的是：在需要进行字符串拼接时，建议的是使用str类型的join方法。而非+
result = ""
for word in ["Hello", "world", "this", "is", "a", "test"]:
result += word + " "
print(result)
第二种：
words = ["Hello", "world", "this", "is", "a", "test"] result = " ".join(words) print(result)
这里面的.join 这样来用的
总结来讲就是：语法结构： “ “.join() 也可以加个,在里面 ()加列表或者元组或者字符串都可以
4.2字符串的常用操作：
4.2.1 index操作
第一次出现的位置
例如：
s= 'hello,hello'
print(s.index('lo'))
4.2.2 rindex
最后一次出现的位置
print(s.rindex('lo'))
一个是3 一个是9 就刚好是9的位置
4.2.3 find
第一次出现的位置，不存在返回-1
4.2.4 rfind
最后一次出现的位置，不存在返回-1
s= 'hello,hello'
print(s.find('k'))
print(s.rfind('j'))
注意的是：都是字符串嘛 所以里面要用引号来写
4.3 字符串大小写转换的方法
4.3.1 upper()
所有字符串转成大写
a='python,HELLO' s=a.upper() print(s)
4.3.2 lower()
所有字符串转成小写
d=a.lower() print(d)
4.3.3 swapcase()
所有大写字母变小写， 小写变大写
4.3.4 capitalize()
把第一个字母转换大写。其余转换小写 只是第一个字母，剩下全小写
4.3.5 title()
把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写。
针对每个单词而言
4.4内容对齐
4.4.1居中对齐
使用对象+.+center(math,'形状') （math-原本长度）/2
例如：
a='python,HELLO' s=a.center(24,'-') print(s)
4.4.2 左对齐
使用ljust(),与居中格式一样，对象名.1just(math.'形状’) ，把形状全部用到右侧
例如：
a = 'python,HELLO' print(a.ljust(20, '-'))
4.4.3右对齐
rjust() str全部移动右面
例如
a = 'python,HELLO' print(a.rjust(20, '-'))
需要注意的是，若没写形状，则默认空格。
4.4.4 0式右对齐
zfill(math) 意思是右对齐，左面用0补齐。
a = 'python,HELLO'
print(a.rjust(20, '-'))
print(a.zfill(20))
print('-8090'.zfill(8))
这里的‘-’算一位，所以左侧有三个0
4.5字符串的劈分操作
4.5.1. split
默认分割符是空格
a = 'python HELLO world' d=a.split() print(d)
还有的是 split('形状‘）
例如：
a = 'python|HELLO|world'
d=a.split('|')
print(d)
还可以规定最大的切割步骤
在上一步基础上，我还是完整的写一遍吧split('形状’，maxsplit=math) math=1,2,3...
例如：
a = 'python|HELLO|world'
d=a.split('|',maxsplit=1)
print(d)
这都是从左面开始劈分的。
4.5.2右面劈分 rsplit
跟左侧很类似，就差一个'r'字母而已。
a = 'python|HELLO|world'
d=a.rsplit('|',maxsplit=1)
print(d)
4.6判断字符串的方法
4.6.1判断合法的字符串
使用isidentifier()
合法的字符串标识符是 字母、数字、下划线、汉字也是，但需要记住字母（大小写均可以）和_可以作为开头这是合理的标识符
a = 'python|HELLO|world'
print(a.isidentifier())
print('hello'.isidentifier())
print('张三_'.isidentifier())
print('123'.isidentifier())
4.6.2 判断字符串是否全部由空白字符串组成（回车、换行、水平制表符）
使用isspace()
a = 'python|HELLO|world'
print(a.isspace())
print('\t'.isspace())
4.6.3判断是否全部由字母组成
使用对象名+.+isalpha()
a = 'python|HELLO|world'
print('python'.isalpha())
print('张三'.isalpha())
总结：终于学到一半了，差不多还有两天就可以学完了。加大强度，令我欣慰的是，中午没有睡午觉哈哈哈哈，同时也祝教师节快乐，祝我的导师节日快乐。
---------出去溜达溜达 20：17----------
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
