Python 的基础知识总结
一、元祖
Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，例如：
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = ("a", "b", "c", "d");
创建空元组，例如：tup = ();
元组中只有一个元素时，需要在元素后面添加逗号，例如：tup1 = (50,);
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
1.1、访问元组
tup1 = ('physics', 'chemistry', 1997, 2000);
#tup1[0]: physics
print "tup1[0]: ", tup1[0]
#tup1[1:5]: ('chemistry', 1997)
print "tup1[1:5]: ", tup1[1:3]
1.2、修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3; #(12, 34.56, 'abc', 'xyz')
1.3、删除元组
元组中的元素值是不允许删除的，可以使用del语句来删除整个元组，例如:
tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
1.4、元组运算符
与字符串一样，元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
1.5、元组索引&截取
L = ('spam', 'Spam', 'SPAM!');
print L[2]; #'SPAM!'
print L[-2]; #'Spam'
print L[1:]; #['Spam', 'SPAM!']
1.6、元组内置函数
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
(seq) 将列表转换为元组。
二、字典
2.1、字典简介
字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：dict = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’};
也可如此创建字典：dict1 = { ‘abc’: 456 };dict2 = { ‘abc’: 123, 98.6: 37 };
每个键与值必须用冒号隔开(每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型。
2.2、访问字典里的值
#!/usr/bin/python
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
print "dict['name']: ", dict['name'];
print "dict['age']: ", dict['age'];
2.3、修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
dict["age"]=27; #修改已有键的值
dict["school"]="wutong"; #增加新的键/值对
print "dict['age']: ", dict['age'];
print "dict['school']: ", dict['school'];
2.4、删除字典
del dict[‘name’]; # 删除键是’name’的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
例如：
#!/usr/bin/python
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
del dict['name'];
#dict {'age': 7, 'class': 'First'}
print "dict", dict;
注意：字典不存在，del会引发一个异常
2.5、字典内置函数&方法
cmp(dict1, dict2) 比较两个字典元素。
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典可打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
clear() 删除字典内所有元素
copy() 返回一个字典的深拷贝(在python中，函数的参数传递是：引用传递)
fromkeys(seq) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
get(key, None) 返回指定键的值，如果值不在字典中返回default值
has_key(key) 如果键在字典dict里返回true，否则返回false
items() 以列表返回可遍历的(键, 值) 元组数组
keys() 以列表返回一个字典所有的键
setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
dict1.update(dict2) 把字典dict2的键/值对更新到dict1里
values() 以列表返回字典中的所有值
三、列表
1.定义
变量可以存储一个元素，而列表是一个大“容器”，可以存储N多个元素，程序可以方便地对这些数据进行整体操作。列表相当于其它语言中的数组。
2.列表的创建
1.列表需要使用中括号[],元素之间使用英文的逗号进行分隔
2.调用内置函数list()
3.列表的特点
1.列表元素按顺序有序排列
2.索引映射唯一一个数据
3.列表可以存储重复数据
4.任意数据类型混合
3.根据需要动态分配和回收内存
4.列表的查询操作
1.获取列表中指定元素的索引 index():
1.如果列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
2.如果查询的元素在列表中不存在，则会抛出ValueError
3.还可以在制定的start和stop之间进行查找
例1：
lst=['hello','python','98','hello']
print(lst.index('hello')) #0
例2：
lst=(['hello','python','world'])
print(lst.index('Baby'))
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_13648/1175636271.py in <module>
1 lst=(['hello','python','world'])
----> 2 print(lst.index('Baby'))
ValueError: 'Baby' is not in list
例3：
lst=['hello','python','98','hello']
print(lst.index('hello',1,4)) #3
2.获取列表中的单个元素
1.正向索引从0到N-1，举例：lst[0]
2.逆向索引从-N到-1，举例：lst[-N]
3.指定索引不存，抛出indexError
例1：
lst=['hello','world',98,'hello','world',234]
print(lst[2]) #获取索引为2的元素
#98
例2:
lst=['hello','world',98,'hello','world',234]
print(lst[-3]) #获取索引为-3的元素
#hello
例3：
lst=['hello','world',98,'hello','world',234]
print(lst[6]) #获取索引为6的元素
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_13648/2375259125.py in <module>
1 lst=['hello','world',98,'hello','world',234]
----> 2 print(lst[6]) #获取索引为6的元素
IndexError: list index out of range
3.获取列表中的多个元素
语法格式：
列表名[start:stop:step]
切片操作：
1.切片的结果（原列表片段的拷贝）
2.切片的范围 [start,stop）
3.step默认为1（简写为[start:stop]
4.step为正数：[:stop:step] 切片的第一个元素默认是列表的第一个元素 （从start开始往后计算切片）
[start::step] 切片的最后一个元素默认是列表的最后一个元素
5.step为负数 [:stop:step] 切片的第一个元素默认是列表的最后一个元素（从start开始往前计算切片） [start::step] 切片的最后一个元素默认是列表的第一个元素
例1：切片的范围、切片的结果
lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1]) #start=1,stop=6,step1
print('原列表',id(lst))
list2=lst[1:6:1]
print('切的片段:',id(lst2))
[20, 30, 40, 50, 60]
原列表 2418471031040
切的片段: 2418470162624
例2：step默认为1
lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1]) #start=1,stop=6,step1
print(lst[1:6]) #start=1,stop=6,默认步长为1
print(lst[1:6:]) #start=1,stop=6,默认步长为1
[20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]
例3:step为正数
lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:2]) #start=1,stop=6,step2
print(lst[:6:2]) #start从最初开始，stop=6,step2
print(lst[1::2]) #start=1,stop到最后,默认步长为1
[20, 40, 60]
[10, 30, 50]
[20, 40, 60, 80]
例4：step为负数
lst=[10,20,30,40,50,60,70,80]
print('原列表',lst)
print(lst[::-1]) #start=7（最后一个）,stop=0,step = -1
print(lst[7::-1]) #start=7，stop=0,step = -1
print(lst[6:0:-2]) #start=6,stop到最后不包括0,step = -2
原列表 [10, 20, 30, 40, 50, 60, 70, 80]
[80, 70, 60, 50, 40, 30, 20, 10]
[80, 70, 60, 50, 40, 30, 20, 10]
[70, 50, 30]
4.判断指定元素在列表中是否存在
1.判断指定定元素在列表中是否存在
元素 in 列表名
元素 not in 列表名
2.列表元素的遍历
for 迭代变量 in 列表名：
操作
例1：
lst=[10,20,'python','hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
print(100 not in lst)
True
False
False
True
例2：
lst=[10,20,'python','hello']
for item in lst:
print(item)
10
20
python
hello
5.列表元素的增加
操作方法：
append() :在列表的末尾添加一个元素
extend() :在列表的末尾至少添加一个元素
insert() :在列表的任意位置添加一个元素
切片 ：在列表的任意位置添加至少一个元素
例1：向列表的末尾添加一个元素
lst=[10,20,30]
print('添加元素前',lst)
lst.append(40)
print('添加元素后',lst)
print('添加元素前',lst,id(lst))
print('添加元素后',lst,id(lst)) id 相同说明还是同一个列表，只是在末尾增加了一个元素
添加元素前 [10, 20, 30]
添加元素后 [10, 20, 30, 40]
添加元素前 [10, 20, 30, 40] 2418471799232
添加元素后 [10, 20, 30, 40] 2418471799232
例2：向列表的末尾至少添加一个元素
lst=[10,20,30]
lst2=['hello','python']
lst.append(lst2) #将lst2作为一个元素添加到lst末尾
print(lst)
[10, 20, 30, ['hello', 'python']]
lst=[10,20,30]
lst2=['hello','python']
lst.extend(lst2) #将lst2的每个元素添加到lst末尾，向列表的末尾添加多个元素
print(lst)
[10, 20, 30, 'hello', 'python']
例3：在列表指定的位置添加元素
lst=[10,20,30]
lst.insert(1,40) #在索引为1的位置添加40
print(lst)
[10, 40, 20, 30]
例4：切片然后在任意位置添加N多个元素
lst=[10,20,30]
lst3=[True,False,'hello']
lst[1:]=lst3 #从索引为1的位置开始到最后切片并替换添加新元素
print(lst)
[10, True, False, 'hello']
6.列表元素的删除
操作方法：
1.remove() :一次删除一个元素
重复元素只删除第一个
元素不存在抛出ValueError
2.pop() :删除一个指定索引位置上的元素
指定索引不存在抛出IndexError
不指定索引，删除列表中最后一个元素
3.切片 ：一次至少删除一个元素
4.clear :清空列表
5.del :删除列表
例1：remove()
lst=[10,20,30,40,50,30]
lst.remove(30)
print(lst) #从列表中移除一个元素，如果有重复元素只移除第一个元素
lst.remove(100) #报错元素不存在
[10, 20, 40, 50, 30]
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_8992/2932006073.py in <module>
2 lst.remove(30)
3 print(lst) #从列表中移除一个元素，如果有重复元素只移除第一个元素
----> 4 lst.remove(100)
ValueError: list.remove(x): x not in list
例2：pop()
lst=[10,20,30,40,50,30]
lst.pop(1) 不指定索引，删除列表中最后一个元素 #从列表中移除索引位置是1的元素
print(lst)
lst.pop(7) #从列表中移除索引位置是7的元素，不存在7的元素报错异常
lst.pop()
print(lst)
[10, 30, 40, 50, 30]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_8992/1736037507.py in <module>
2 lst.pop(1) #从列表中移除索引位置是1的元素
3 print(lst)
----> 4 lst.pop(7) #从列表中移除索引位置是7的元素，不存在7的元素报错异常
5 lst.pop()
6 print(lst)
IndexError: pop index out of range
lst=[10,20,30,40,50,30]
lst.pop() #不指定索引，删除列表中最后一个元素
print(lst)
[10, 20, 30, 40, 50]
例3：切片
lst=[10,20,30,40,50,30]
new_list=lst[1:3] #切片操作删除至少一个元素，将产生一个新的列表对象
print('原列表',lst)
print('切片后的列表',new_list)
原列表 [10, 20, 30, 40, 50, 30]
切片后的列表 [20, 30]
lst=[10,20,30,40,50,30]
lst[1:3]=[] #切片操作删除原列表中的内容，不产生新的列表,把索引的1和2的元素删除
print(lst)
[10, 40, 50, 30]
例4：clear
lst=[10,20,30,40,50,30]
lst.clear() #清除列表中的所有元素
print(lst)
[]
例5：del
lst=[10,20,30,40,50,30]
del lst #直接清除列表对象
print(lst) #报错 'lst' is not defined
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_8992/1850059668.py in <module>
1 lst=[10,20,30,40,50,30]
2 del lst
----> 3 print(lst)
NameError: name 'lst' is not defined
7.列表元素的修改操作
1.为指定索引的元素赋予一个新值
2.为指定的切片赋予一个新值
例1：
lst=[10,20,30,40]
lst[2]=100 #修改索引为2的元素换成100
print(lst)
[10, 20, 100, 40]
例2：
lst=[10,20,30,40]
lst[1:2]=[50,60,70,80] #索引1和2的值换成50，60，70，80
print(lst)
[10, 50, 60, 70, 80, 30, 40]
8.列表元素的排序操作
1.调用sort()方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True,进行降序排序
2.调用内置函数sorted(),可以指定reverse=True,进行降序排序，原列表不发生改变，排序后产生一个新的列表对象
例1：sort()，对原列表进行排序
lst=[20,40,10,98,54]
print('排序前的列表',lst,id(lst))
lst.sort() #通过指定关键字参数，将列表中的元素进行升序排序
print('排序后的列表',lst,id(lst)) #id 相同说明原列表对象不变，只是做个排序处理
lst.sort(reverse=True) #reverse=True 表示降序排列
print(lst)
lst.sort(reverse=False) #reverse=False 表示降序排列
print(lst)
排序前的列表 [20, 40, 10, 98, 54] 2500174974080
排序后的列表 [10, 20, 40, 54, 98] 2500174974080
[98, 54, 40, 20, 10]
[10, 20, 40, 54, 98]
例2：sorted(),原列表不变，排序后产生一个新的列表对象
lst=[20,40,10,98,54]
print(lst)
new_list=sorted(lst) #升序排序，排序后的是一个新的列表对象
print(new_list)
new_list=sorted(lst,reverse=True) #降序排序，排序后是一个新的列表对象
print(new_list)
[20, 40, 10, 98, 54]
[10, 20, 40, 54, 98]
[98, 54, 40, 20, 10]
9.列表生成式（生成列表的公式）
语法格式：
[i*i for i in range(1,10)]
i*i 表示列表元素
i 表示自定义变量
range() 可迭代对象
**注意事项：‘表示列表元素的表达式’中通常包含自定义变量
例：
lst=[i for i in range(1,10)]
print(lst)
lst2=[i*i for i in range(1,10)]
print(lst2)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
例：列表中的元素是2，4，6，8，10
lst=[i*2 for i in range(1,6)]
print(lst)
[2, 4, 6, 8, 10]