一 列表

类似c#数组，但是列表元素没有类型限制

li = []一个空列表
li = [1,2,3,"a",4] 一个有值的列表

列表可以迭代

for i in li:
    print(i)

1插入元素

append()
整体追加

li = ["one","two","three"]
li.append("four")
for i in li:
    print(i)#one two three four

extend()
将另一个迭代器的内容逐项添加，如果参数不是一个可迭代对象，会报错

li = ["one","two","three"]
li.extend("four")
for i in li:
    print(i)#one two three f o u r

insert()
在指定位置处添加

li = ["one","two","three"]
li.insert(1,"four",)
for i in li:
    print(i)#one four two three

2查询

**in和 not in ** 元素是否存在/不存在，返回Bool ，注意这两个不是方法

li = ["one","two","three"]
print("one" in li) #输出True

index()
如果元素存在，返回索引，如果不存在报错，列表没有find方法
参数2 3可以指定查找范围

li = ["one","two","three"]
print(li.index("one"))

count()
元素在列表中出现的次数
只能从整个列表中查找

li = ["one","two","three"]
print(li.count("one"))

len()
获取列表的长度

li=[1,2,3]
print(len(li))#输出3

3删除

del
删除整个表或某个元素，注意这不是方法

li = ["one","two","three"]
del li[0] #删除第0个元素
del li #删除整个表

pop()
删除最后一个元素或指定元素，有返回值，返回被删除的元素，这是一个方法

li = ["one","two","three"]
de = li.pop() 没有参数默认删除最后一个
print(de)#输出three
print(li)#输出['one', 'two']

remove()
根据元素的值删除，只删除第一个匹配值，没有匹配值会报错

li = ["one","one","two","three"]
li.remove("one")
print(li)#['one', 'two', 'three']

4排序

sort()
从小到大排序，字母按字母顺序排序

li = ["one","one","two","three"]
li.sort()
print(li)#['one', 'one', 'three', 'two']

reverse()
翻转列表元素

5切片

li=[1,2,3,4]
print(li[1:3])#输出[2, 3] 索引包前不包后 前后都可以省略，分别是从头切和切到尾

6列表推导式

格式1
[表达式 for 元素in 迭代器] 中括号是必须的

li=[]
[li.append(i) for i in range(1,6)]
print(li)#输出[1, 2, 3, 4, 5]

格式2
[表达式 for 元素in 迭代器 if条件] 中括号是必须的

li=[]
[li.append(i) for i in range(1,11) if i%2 ==1]
print(li)#输出[[1, 3, 5, 7, 9]]

二 元组

类似c#数组，但是元组元素没有类型限制

tua =(1,2)

注意，如果只有一个元素，后边要加逗号，否则会被解释器理解为一个变量

tua =(1)
print(type(tua))#输出<class 'int'> tua被理解为一个int变量

tua =(1,)
print(type(tua))#<class 'tuple'> 加上逗号正确识别为一个元组

tua =()
print(type(tua))#<class 'tuple'> 定义空元组可以只写()

1元组的特点和作用

不允许修改内容，只能查
占位符输出时使用的是元组

name="wuzi"
age=20
print("我的名字是%s，我的年龄是%d" %(name,age))
tua=("wuzi",20)
print("我的名字是%s，我的年龄是%d" %tua) #两者等价

2查询元素

in notin count() index() length 同列表

三 字典

1定义

经典的键值对，键要有唯一性，键和值的类型没有限制
如果有两个

dic={1:"wuzi","age":18}
print(dic)#输出结果{1: 'wuzi', 'age': 18}

键名重复不会报错，但是会覆盖前边的值

dic={1:"wuzi","age":18,"age":19}
print(dic)#输出{1: 'wuzi', 'age': 19}

2查询

两种方式

dic={"name":"wuzi","age":19}
print(dic["age"])#输出19 键不存在会报错
print(dic.get("age"))#输出19  键不存在返回None
print(dic.get("height","键不存在"))#输出 键不存在  可以指定一个键不存在时的提示

3修改

dic={"name":"wuzi","age":19}
dic["age"]= 20
dic["hegiht"]=180
print(dic)#输出{'name': 'wuzi', 'age': 20, 'hegiht': 180} 如果键不存在将会自动新增

4添加

dic["hegiht"]=180 #如果键不存在，会自动新加

5删除

del
删除整个对象 或 键值对 del不是方法，是python的内置语句

#删除对象
dic={"name":"wuzi","age":19}
del dic
print(dic)#输出报错，因为字典的对象已经被删除

#删除键值对 键不存在会报错
dic={"name":"wuzi","age":19}
del dic["age"]
print(dic)#输出{'name': 'wuzi'}

clear()
清空字典

dic={"name":"wuzi","age":19}
dic.clear()
print(dic)#输出{}

pop()
移除一个元素，并返回被移除的值，和del不同,pop是dic自带的内置方法

dic={"name":"wuzi","age":19}
d = dic.pop("age")
print(d)#输出19 被移除的值
print(dic)

popitem()
3.7之前是随机删除一个键值对，3.7之后是删除最后一个键值对

dic={"name":"wuzi","age":19}
d = dic.popitem()
print(dic)#{'name': 'wuzi'}

6长度

len()
这不是dic的方法，而是Python的全局方法，dic自带的是 dic.len()，len()内部会调用这个方法

dic={"name":"wuzi","age":19}
print(len(dic))#2

7获取所有键

keys()

dic={"name":"wuzi","age":19}
print(dic.keys())#输出 dict_keys(['name', 'age'])#keys()返回的类型为dict_keys，这是一个迭代器
for i in dic.keys():
    print(i)#循环打印键名  此外如果直接for i in dic也将打印键名

8获取所有值

values()

dic={"name":"wuzi","age":19}
print(dic.values())#输出 dict_values(['wuzi', 19])
for i in dic.values():
    print(i)#循环打印值

9获取所有键值对

items()

dic={"name":"wuzi","age":19}
print(dic.items())#输出 dict_items([('name', 'wuzi'), ('age', 19)])
for i in dic.items():
    print(i)#循环打印值

四 集合

集合set不能有重复值 不能修改 可以自动去重
集合是无序的，取出的顺序和放入的顺序无关，每次运行都会不一样(只有数字的顺序和放入顺序固定一致)

s1={1,2,3}
s2=set{} #使用这种方式定义一个空集合，如果直接s2={}会被识别为一个字典
#自动去重
s3={1,2,3,4,4,4}
print(s3)#输出{1, 2, 3, 4}

1添加元素

add()
整体添加，一次只能添加一个

s3={1,2,3,4}
s3.add(5)
print(s3)#输出{1, 2, 3, 4, 5}

update()
添加一个迭代对象里的元素

s3={1,2,3,4}
s3.update((5,6,7)) #括号里需要是一个可迭代对象 这里是一个元组
print(s3)#输出{1, 2, 3, 4, 5, 6, 7}

2删除元素

remove() 删除指定的元素 参数是元素，不是索引，如果元素不存在会报错

s3={1,2,3,4}
s3.remove(1)
print(s3)#输出{2, 3, 4}

pop()
删除无序排列后的第一元素，剩下的元素不会重新排序

s3={"1","2","3","4"}
s3.pop()
print(s3)#输出{'3', '1', '4'}
s3.pop()
print(s3)#输出{'1', '4'}

discard() 删除指定的元素，元素不存在，不会报错

s3={"1","2","3","4"}
s3.discard("2")
print(s3)#输出{'3', '4', '1'}

3 交集和并集

交集
取共有的部分，用&符号
如果没没有交集会返回 set() 这是一个空集合

s3={"1","2","3","4"}
s4={"1","5"}
print(s3&s4)#输出{'1'}

s3={"1","2","3","4"}
s4={"5"}
print(s3&s4)#输出set()  空集合

并集 用|符号

s3={"1","2","3","4"}
s4={"1","5"}
print(s3|s4)#输出{'5', '1', '3', '4', '2'}