python学习3

1. 列表 相当于数组

1. 列表的创建和删除

1. 直接用[]声明

a='1'
li=[1,2,a]

2. 使用range函数创造迭代器核心，再用list()方法来创建

ran = range(5,10,2)
li = list(ran)

3. 也可以 使用list作为核心，再用list()方法来创建 ,应该可以用作浅复制；

a='1'
li=[1,2,a]
li1 = list(li)

2. 列表的增删改查操作

1. 增

• 1 . append方法 追加一个元素到数组末尾

li1 = [1,2,3]
li2 = [1,2,3]
li=[1,li1,3,4,5,6,7,8,9,0]
li.append(li2)

• 2 . extend 散开数组元素追加到数组末尾

li1 = [1,2,3]
li2 = [1,2,3]
li=[1,li1,3,4,5,6,7,8,9,0]
li.extend(li2)

结果： [1, [1, 2, 3], 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3]

• 3 . insert 在列表任意位置加入元素

li1 = [1,2,3]
li2 = [1,2,3]
li=[1,li1,3,4,5,6,7,8,9,0]
li.insert(2,li2)
print(li)

• 4 . 切片 其实不是添加了，其实是切掉替换 ,注意切的位置也可以实现增加

li1 = [1,2,3]
li=[1,2,3,4,5,6,7,8,9,0]
li[1:]=li1
print(li)

2. 删

• 1 . remove() 根据值删除元素

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li.remove('ccc')
print(li)

一次删除一个，重复的话只会删除第一个值， 如果值不存在就报valueError

• 2 . pop() 根据索引删除元素

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li.pop(100)
print(li)

一次删除一个 如果索引不存在就报indexError，如果没有指定索引，那么就删除最后一个

• 3 . 切片 变相的做法 把某一段范围的元素用空列表替代

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li[1:9]=[]
print(li)

• 4 . clear 清空一个列表 类似于 li=[]

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li.clear()
print(li)

• 5 . del 删除一个列表 ,删除了一个列表的引用，会报错

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
del li 
print(li)

3. 改

• 1 . 使用索引指定一个新值

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li[9]=['hello','world']
print(li)

• 2 . 切片 把列表上某一段范围的元素用其他列表替代

li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li[1:9]=['hello','world']
print(li)

4. 查

• 1 . 正向索引

li = 【1，2，3】 print(li[2])

0 到 n-1 为正常索引 超出报错

• 2 . 倒向索引

li = 【1，2，3】 print(li[-2])

-n 到 -1 为正常索引 超出报错

• 3 . 获取切片操作 是一个原列表片段的浅拷贝 范围也是左闭右开,语法 [起始（默认0）:结束（默认为长度-1）:步长（默认为1）]

li=[1,2,3,4,5,6,7,8,9,0]
print(li[1:3:1])

起始 结束 步长也可以为负数，不过一般不常用，倒序拷贝输出，可以用来reverse倒排(reverse对自身改变)， 不需要掌握

3. 列表元素的排序 注意 类型必须一样哦 字符串和数字混着来会报错的哦

1. 列表的sort 方法 改变原列表

li=[5,6,7,8,9,0]
li.sort(reverse=True)
print(li)

2. 内置函数sorted方法产生新的列表 不改变原列表

li=[5,6,7,8,9,0]
li2 = sorted(li,reverse=True)
print(li2)

4. 列表的推导生成式

[ ii for i in range(1,10)] 中括号含有两部分，1，值部分可以是一个表达式 ii 2，迭代器发动机部分 for in语句

li=[i*i for i in range(1,10)]
print(li)

5. index方法

index()方法也是返回第一个下标,没有会报错不会返回-1，这个和其他语言不同,

第2，3个参数可以指定查询范围，左闭右开

6. in & not in

元素是否存在列表返回布尔值

但是对于复杂类型的元素 ，这边应该使用的是粗糙的值比价，而不是精准的内存地址比较

7. 可以使用for in和while进行循环 （类似有迭代器的都可以进行循环）

2.字典 就是其他语言中的对象

1 . 字典的原理

简单来说字典是一个巨大的稀疏列表，典型以空间换时间的做法，key的实际索引值是通过hash算法得到一个巨大切不重复的值 hash值很少会撞针

字典的元素是无序的

key不允许重复如果重复将会被覆盖
key必须为不可变对象不能是一个复合结构 可以为字符串、数字、元祖还有False

2 . 字典的创建

1. 以{}字面量创建

di = {'a':1,1:2}
di[4]=5
print(di)

2. dict()方法创建

di = dict(a=1,b=2) # 不能创建数字key
di[4]=5
print(di)

3 . 字典的增删改查

1. 增

• 1 . 直接 dict[key] =value

di = dict(a=1,b=2)
di['c']=100
print(di)

2. 删

• 1 . del

di = dict(a=1,b=2)
del di['a']
print(di)

• 2 . clear 清空字典

di = dict(a=1,b=2)
di.clear()
print(di)

3. 改

• 1 . 直接 dict[key] =value

di = dict(a=1,b=2)
di['a']=100
print(di)

4. 查

• 1 . []

di = dict(a=1,b=2)
print(di['a'])

查找没有的key 会报keyError

• 2 . 使用get(key)

di = dict(a=1,b=2)
print(di.get('a'))

如果查找不存在，会返回none ，这个时候还可以指定默认值，为第二个参数

di = dict(a=1,b=2)
print(di.get('c',3))

4 . 字典的推导生成式 使用内置函数zip()进行打包

语法为 {} 包含两部分 1， 键值对示意表达式 2， for in 循环

zip 函数的参数必须为两个迭代器对象

如果两个迭代器对象长度不一致以短的那个长度为准

items = ['中华','芙蓉王','玉溪']
prices= [50,28,23]
di = { item:price for item, price in zip(items,prices)}
print(di)

5 . key 是否存在 in & not in 返回布尔值

di = dict(a=1,b=2)
print('a' in di)

6. 字典的视图 都是类似于range的迭代器类型，可以使用list进行转换为列表

1. keys type 为 dict_keys,

di = dict(a=1,b=2)
diKeys=di.keys()
print(diKeys)
for key in diKeys:
    print(di[key])

2. values type 为 dict_values

di = dict(a=1,b=2)
diValues=di.values()
print(list(diValues))

3. items type 为 dict_items, 每一项都是一个元祖’tuple’

di = dict(a=1,b=2)
diItems=di.items()
print(list(diItems))
for item in diItems:
    print(type(item))

7. 字典的循环

di = dict(a=1,b=2)
for item in di:
    print(item,di[item],di.get(item))

3. 元祖 tuple

1. 什么是元祖

元祖是一个不可变队列, 里面存放的内存地址都不可以改变的

不可变队列是指不能增删改等操作，字符串数组，改变就会产生新的地址

可变队列是指可以改变的 如列表，字典， 地址不会发生变化

没有元祖的推导生成式

2. 元祖的创建方式

1. 直接小括号()

tu = (1,2,3)
print(type(tu))

2. 使用内置函数tuple() 注意是两层括号

tu = tuple((1,2,3))
print(tu)

3. 只包含一个元祖的元素需要使用逗号和小括号 (,),（否则就是元素的值而已，不是元祖类型了）

tu = (1,)
print(tu)

4. 空元祖 两种方式 tu = (),tu = tuple()

3. 元祖的遍历 for in

tu = (1,2,3)
for t in tu:
    print(t)

4. 元祖的查询方式

tu = (1,2,3)
print(tu[1])

4. 集合 set

类似于字典但是只有key，没有value
可以是无序的

1. 集合的创建方式

1. {}

s = {1,2,3,4}
print(type(s))

2. set() ，可以去重, 参数有 字符串，元祖 ，列表，range，set本身，不传（空集合）

print(set(range(0,10)))
print(set('python'))
print(set((1,2,3,3)))
print(set([1,2,3,3]))
print(set({1,2,3,3}))
print(set())

2. 集合的增删改查

1. 增

• 1 . add()，添加一个元素到末尾

s={1,2,3}
s.add(4)
print(s)

• 2 . update() 参数必须为列表 元祖 集合，否则报错，至少可以添加一个元素到末尾

s={1,2,3}
s.update([4,5,6])
s.update((7,8))
s.update({9})
print(s)

2. 删

• 1 . remove 删除一个指定元素，如果没有会报keyError

s={1,2,3}
s.remove(2)
print(s)

• 2 . discard() 删除一个指定元素，如果没有不会报错

s={1,2,3}
s.discard(2)
s.discard(5)
print(s)

• 3 . pop 删除一个任意的字符，不能指定参数,空集合使用会报错

s={1,2,3}
s.pop()
s.pop()
s.pop()
print(s)

• 4 . clear 清空集合

s={1,2,3}
s.clear()
print(s)

3. 集合的生成式

公式在{}内由两部分构成： 1. 实际value生成部分可以是个表达式 i*i 2. for in 迭代器部分

s1={ i*i for i in range(1,10)}
print(s1)

4. 集合的 in & not in

s= {1,2,3}
print(1 in s )

5. 集合之间的关系

1. 是否相等使用 == 或者!= 来判断 返回布尔指

s1={1,2,3}
s2={1,2,3}
s3={4,5,6}
print(s1==s2)
print(s1!=s2)
print(s3!=s1)
print(s3==s1)

2. 一个集合是否是另外一个集合的子集 issubset()

s1={1,2,3}
s2={1,2,3,4,5,6}
s3={4,5,6}
print(s1.issubset(s2))
print(s1.issubset(s3))

3. 一个集合是否是另外一个集合的超集 issuperset()

s1={1,2,3,4,5,6,7}
s2={1,2,3,4,5,6}
s3={4,5,6}
print(s1.issuperset(s2))
print(s1.issuperset(s3))

4. 两个集合是否没有交集 isdisjoint() 注意是dis 反向的 没有交集

s1={1,2,3}
s2={1,2,3,4,5,6}
s3={4,5,6}
print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))

6. 集合的数学操作

1. 交集 intersection() 简写为&

s1={1,2,3}
s2={1,4,5,6}
print(s1.intersection(s2))
print(s1&s2)

2. 并集 union() 简写为｜

s1={1,2,3}
s2={1,4,5,6}
print(s1.union(s2))
print(s1|s2)

3. 差集 difference() 简写为 - 相对于前面那个集合的差集

s1={1,2,3}
s2={1,4,5,6}
print(s1.difference(s2))
print(s1-s2)

4. 对称差集 symmetric_difference() 简写为^ 两个集合的非交集部分

s1={1,2,3}
s2={1,4,5,6}
print(s1.symmetric_difference(s2))
print(s1^s2)

7. 集合的遍历 for in

s1={1,2,3}
for i in s1:
    print(i)