python基础入门语法和变量类型（二）
列表
列表是 Python 中使用最频繁的数据类型，它可以完成大多数集合类的数据结构实现，可以包含不同类型的元素，包括数字、字符串，甚至列表（也就是所谓的嵌套）。
和字符串一样，可以通过索引值或者切片(截取)进行访问元素，索引也是从 0 开始，而如果是倒序，则是从 -1 开始。列表截取的示意图如下所示：
另外，还可以添加第三个参数作为步长：
同样，列表也有很多内置的方法，这里介绍一些常见的方法：
len(list)：返回列表的长度
append(obj) / insert(index, obj) / extend(seq)：增加元素的几个方法
pop() / remove(obj) / del list[index] / clear()：删除元素
reverse() / reversed：反转列表
sort() / sorted(list)：对列表排序，注意前者会修改列表内容，后者返回一个新的列表对象，不改变原始列表
index()：查找给定元素第一次出现的索引位置
初始化列表的代码示例如下：
# 创建空列表，两种方法
list1 = list()
list2 = []# 初始化带有数据
list3 = [1, 2, 3]
list4 = ["a", 2, "nb", [1, 3, 4]]
print("list1:", list1)
print("list2:", list2)
print("list3:", list3)
print("list4:", list4)
print("len(list4): ", len(list4))
添加元素的代码示例如下：
# 末尾添加元素
list1.append("abc")
print("list1:", list1)# 末尾添加另一个列表，并合并为一个列表
list1.extend(list3)
print("list1.extend(list3), list1:", list1)
list1.extend((1, 3))
print("list1.extend((1,3)), list1:", list1)# 通过 += 添加元素
list2 += [1, 2, 3]
print("list2:", list2)
list2 += list4
print("list2:", list2)# 在指定位置添加元素,原始位置元素右移一位
list3.insert(0, "a")
print("list3:", list3)# 末尾位置添加，原来末尾元素依然保持在末尾
list3.insert(-1, "b")
print("list3:", list3)
删除元素的代码示例如下：
# del 删除指定位置元素del list3[-1]
print("del list3[-1], list3:", list3)# pop 删除元素
pop_el = list3.pop()
print("list3:", list3)
print("pop element:", pop_el)# pop 删除指定位置元素
pop_el2 = list3.pop(0)
print("list3:", list3)
print("pop element:", pop_el2)# remove 根据值删除元素
list3.remove(1)
print("list3:", list3)# clear 清空列表
list3.clear()
print("clear list3:", list3)
查找元素和修改、访问元素的代码示例如下：
# index 根据数值查询索引
ind = list1.index(3)
print("list1.index(3)，index=", ind)# 访问列表第一个元素
print("list1[0]: ", list1[0])# 访问列表最后一个元素
print("list1[-1]: ", list1[-1])# 访问第一个到第三个元素
print("list1[:3]: ", list1[:3])# 访问第一个到第三个元素,步长为2
print("list1[:3:2]: ", list1[:3:2])# 复制列表
new_list = list1[:]
print("copy list1, new_list:", new_list)
排序的代码示例如下：
list5 = [3, 1, 4, 2, 5]
print("list5:", list5)# use sorted
list6 = sorted(list5)
print("list6=sorted(list5), list5={}, list6={}".format(list5, list6))# use list.sort()
list5.sort()
print("list5.sort(), list5: ", list5)
sorted() 都不会改变列表本身的顺序，只是对列表临时排序，并返回一个新的列表对象；
相反，列表本身的 sort() 会永久性改变列表本身的顺序。
另外，如果列表元素不是单纯的数值类型，如整数或者浮点数，而是字符串、列表、字典或者元组，那么还可以自定义排序规则，这也就是定义中最后两行，例子如下：
# 列表元素也是列表
list8 = [[4, 3], [5, 2], [1, 1]]
list9 = sorted(list8)
print("list9 = sorted(list8), list9=", list9)# sorted by the second element
list10 = sorted(list8, key=lambda x: x[1])
print("list10 = sorted(list8, key=lambda x:x[1]), list10=", list10)
list11 = sorted(list8, key=lambda x: (x[1], x[0]))
print("list11 = sorted(list8, key=lambda x:(x[1],x[0])), list11=", list11)# 列表元素是字符串
list_str = ["abc", "pat", "cda", "nba"]
list_str_1 = sorted(list_str)
print("list_str_1 = sorted(list_str), list_str_1=", list_str_1)# 根据第二个元素排列
list_str_2 = sorted(list_str, key=lambda x: x[1])
print("list_str_2 = sorted(list_str, key=lambda x: x[1]), list_str_2=", list_str_2)# 先根据第三个元素，再根据第一个元素排列
list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0]))
print("list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])), list_str_3=", list_str_3)
反转列表的代码示例如下：
# 反转列表
list5.reverse()
print("list5.reverse(), list5: ", list5)
list7 = reversed(list5)
print("list7=reversed(list5), list5={}, list7={}".format(list5, list7))#for val in list7:# print(val)# 注意不能同时两次
list7_val = [val for val in list7]
print("采用列表推导式, list7_val=", list7_val)
list8 = list5[::-1]
print("list5 = {}
list_reversed = list5[::-1], list_reversed = {}".format(list5, list_reversed))
reverse() 方法会永久改变列表本身，而 reversed() 不会改变列表对象，它返回的是一个迭代对象，如例子输出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要获取其排序后的结果，需要通过 for 循环，或者列表推导式，但需要注意，它仅仅在第一次遍历时候返回数值。
以及，一个小小的技巧，利用切片实现反转，即 <list> = <list>[::-1]。
元组
元组和列表比较相似，不同之处是元组不能修改，然后元组是写在小括号 () 里的。
元组也可以包含不同的元素类型。简单的代码示例如下：
t1 = tuple()
t2 = ()
t3 = (1, 2, "2", [1, 2], 5)# 创建一个元素的元祖
t4 = (7, )
t5 = (2)
print("创建两个空元组：t1={}, t2={}".format(t1, t2))
print("包含不同元素类型的元组：t3={}".format(t3))
print("包含一个元素的元祖: t4=(7, )={}, t5=(2)={}".format(t4, t5))
print("type(t4)={}, type(t5)={}".format(type(t4), type(t5)))
print("输出元组的第一个元素：{}".format(t3[0]))
print("输出元组的第二个到第四个元素：{}".format(t3[1:4]))
print("输出元祖的最后一个元素: {}".format(t3[-1]))
print("输出元祖两次: {}".format(t3 * 2))
print("连接元祖: {}".format(t3 + t4))
元祖和字符串也是类似，索引从 0 开始，-1 是末尾开始的位置，可以将字符串看作一种特殊的元组。
此外，从上述代码示例可以看到有个特殊的例子，创建一个元素的时候，必须在元素后面添加逗号，即如下所示:
tup1 = (2,) # 输出为 (2,)
tup2 = (2) # 输出是 2
print("type(tup1)={}".format(type(tup1))) # 输出是 <class "tuple">
print("type(tup2)={}".format(type(tup2))) # 输出是 <class "int">
还可以创建一个二维元组，代码例子如下：
# 创建一个二维元组
tups = (1, 3, 4), ("1", "abc")
print("二维元组: {}".format(tups)) # 二维元组: ((1, 3, 4), ("1", "abc"))
然后对于函数的返回值，如果返回多个，实际上就是返回一个元组，代码例子如下：
def print_tup():
return 1, "2"
res = print_tup()
print("type(res)={}, res={}".format(type(res), res)) # type(res)=<class "tuple">, res=(1, "2")
元组不可修改，但如果元素可修改，那可以修改该元素内容，代码例子如下所示：
tup11 = (1, [1, 3], "2")
print("tup1={}".format(tup11)) # tup1=(1, [1, 3], "2")
tup11[1].append("123")
print("修改tup11[1]后，tup11={}".format(tup11)) # 修改tup11[1]后，tup11=(1, [1, 3, "123"], "2")
因为元组不可修改，所以仅有以下两个方法：
count(): 计算某个元素出现的次数
index(): 寻找某个元素第一次出现的索引位置
代码例子：
# count()
print("tup11.count(1)={}".format(tup11.count(1)))# index()
print("tup11.index("2")={}".format(tup11.index("2")))
字典
字典也是 Python 中非常常用的数据类型，具有以下特点：
它是一种映射类型，用 {} 标识，是无序的键(key): 值(value) 的集合；
键(key) 必须使用不可变类型；
同一个字典中，键必须是唯一的；
创建字典的代码示例如下，总共有三种方法：
# {} 形式
dic1 = {"name": "python", "age": 20}# 内置方法 dict()
dic2 = dict(name="p", age=3)# 字典推导式
dic3 = {x: x**2 for x in {2, 4, 6}}
print("dic1={}".format(dic1)) # dic1={"age": 20, "name": "python"}
print("dic2={}".format(dic2)) # dic2={"age": 3, "name": "p"}
print("dic3={}".format(dic3)) # dic3={2: 4, 4: 16, 6: 36}
常见的三个内置方法，keys(), values(), items() 分别表示键、值、对，例子如下：
print("keys()方法，dic1.keys()={}".format(dic1.keys()))print("values()方法, dic1.values()={}".format(dic1.values()))print("items()方法, dic1.items()={}".format(dic1.items()))
其他对字典的操作，包括增删查改，如下所示：
# 修改和访问
dic1["age"] = 33
dic1.setdefault("sex", "male")
print("dic1={}".format(dic1))# get() 访问某个键
print("dic1.get("age", 11)={}".format(dic1.get("age", 11)))
print("访问某个不存在的键，dic1.get("score", 100)={}".format(dic1.get("score", 100)))# 删除del dic1["sex"]
print("del dic1["sex"], dic1={}".format(dic1))
dic1.pop("age")
print("dic1.pop("age"), dic1={}".format(dic1))# 清空
dic1.clear()
print("dic1.clear(), dic1={}".format(dic1))# 合并两个字典
print("合并 dic2 和 dic3 前, dic2={}, dic3={}".format(dic2, dic3))
dic2.update(dic3)
print("合并后，dic2={}".format(dic2))
# 遍历字典
dic4 = {"a": 1, "b": 2}for key, val in dic4.items():
print("{}: {}".format(key, val))# 不需要采用 keys()for key in dic4:
print("{}: {}".format(key, dic4[key]))
最后，因为字典的键必须是不可改变的数据类型，那么如何快速判断一个数据类型是否可以更改呢？有以下两种方法：
id()：判断变量更改前后的 id，如果一样表示可以更改，不一样表示不可更改。
hash()：如果不报错，表示可以被哈希，就表示不可更改；否则就是可以更改。
首先看下 id() 方法，在一个整型变量上的使用结果：
i = 2
print("i id value=", id(i))
i += 3
print("i id value=", id(i))
输出结果，更改前后 id 是更改了，表明整型变量是不可更改的。
i id value= 1758265872
i id value= 1758265968
然后在列表变量上进行同样的操作：
l1 = [1, 3]
print("l1 id value=", id(l1))
l1.append(4)
print("l1 id value=", id(l1))
输出结果，id 并没有改变，说明列表是可以更改的。
l1 id value= 1610679318408
l1 id value= 1610679318408
然后就是采用 hash() 的代码例子：
# hash
s = "abc"
print("s hash value: ", hash(s))
l2 = ["321", 1]
print("l2 hash value: ", hash(l2))
输出结果如下，对于字符串成功输出哈希值，而列表则报错 TypeError: unhashable type: "list"，这也说明了字符串不可更改，而列表可以更改。
s hash value: 1106005493183980421
TypeError: unhashable type: "list"
集合
集合是一个无序的不重复元素序列，采用大括号 {} 或者 set() 创建，但空集合必须使用 set() ，因为 {} 创建的是空字典。
创建的代码示例如下：
# 创建集合
s1 = {"a", "b", "c"}
s2 = set()
s3 = set("abc")
print("s1={}".format(s1)) # s1={"b", "a", "c"}
print("s2={}".format(s2)) # s2=set()
print("s3={}".format(s3)) # s3={"b", "a", "c"}
注意上述输出的时候，每次运行顺序都可能不同，这是集合的无序性的原因。
利用集合可以去除重复的元素，如下所示：
s4 = set("good")
print("s4={}".format(s4)) # s4={"g", "o", "d"}
集合也可以进行增加和删除元素的操作，代码如下所示：
# 增加元素，add() 和 update()
s1.add("dd")
print("s1.add("dd"), s1={}".format(s1)) # s1.add("dd"), s1={"dd", "b", "a", "c"}
s1.update("o")
print("添加一个元素，s1={}".format(s1)) # 添加一个元素，s1={"dd", "o", "b", "a", "c"}
s1.update(["n", 1])
print("添加多个元素, s1={}".format(s1)) # 添加多个元素, s1={1, "o", "n", "a", "dd", "b", "c"}
s1.update([12, 33], {"ab", "cd"})
print("添加列表和集合, s1={}".format(s1)) # 添加列表和集合, s1={1, 33, "o", "n", "a", 12, "ab", "dd", "cd", "b", "c"}
# 删除元素, pop(), remove(), clear()
print("s3={}".format(s3)) # s3={"b", "a", "c"}
s3.pop()
print("随机删除元素, s3={}".format(s3)) # 随机删除元素, s3={"a", "c"}
s3.clear()
print("清空所有元素, s3={}".format(s3)) # 清空所有元素, s3=set()
s1.remove("a")
print("删除指定元素,s1={}".format(s1)) # 删除指定元素,s1={1, 33, "o", "n", 12, "ab", "dd", "cd", "b", "c"}
此外，还有专门的集合操作，包括求取两个集合的并集、交集
# 判断是否子集, issubset()
a = set("abc")
b = set("bc")
c = set("cd")
print("b是否a的子集:", b.issubset(a)) # b是否a的子集: True
print("c是否a的子集:", c.issubset(a)) # c是否a的子集: False
# 并集操作，union() 或者 |
print("a 和 c 的并集:", a.union(c)) # a 和 c 的并集: {"c", "b", "a", "d"}
print("a 和 c 的并集:", a | c) # a 和 c 的并集: {"c", "b", "a", "d"}
# 交集操作，intersection() 或者 &
print("a 和 c 的交集:", a.intersection(c)) # a 和 c 的交集: {"c"}
print("a 和 c 的交集:", a & c) # a 和 c 的交集: {"c"}
# 差集操作，difference() 或者 - ，即只存在一个集合的元素
print("只在a中的元素:", a.difference(c)) # 只在a中的元素:: {"b", "a"}
print("只在a中的元素:", a - c) # 只在a中的元素:: {"b", "a"}
# 对称差集, symmetric_difference() 或者 ^, 求取只存在其中一个集合的所有元素
print("对称差集:", a.symmetric_difference(c)) # 对称差集: {"a", "d", "b"}
print("对称差集:", a ^ c) # 对称差集: {"a", "d", "b"}
数据类型的转换
有时候我们需要对数据类型进行转换，比如列表变成字符串等，这种转换一般只需要将数据类型作为函数名即可。下面列举了这些转换函数：
int(x, [,base])：将 x 转换为整数，base 表示进制，默认是十进制
float(x)：将 x 转换为一个浮点数
complex(x, [,imag])：创建一个复数, imag 表示虚部的数值，默认是0
str(x)：将对象 x 转换为字符串
repr(x)：将对象 x 转换为表达式字符串
eval(str)：用来计算在字符串中的有效 Python 表达式,并返回一个对象
tuple(s)：将序列 s 转换为一个元组
list(s)：将序列 s 转换为一个列表
set(s)：转换为可变集合
dict(d)：创建一个字典。d 必须是一个序列 (key,value)元组
frozenset(s)：转换为不可变集合
chr(x)：将一个整数转换为一个字符
ord(x)：将一个字符转换为它的整数值
hex(x)：将一个整数转换为一个十六进制字符串
oct(x)：将一个整数转换为一个八进制字符串
以上是 python基础入门语法和变量类型（二） 的全部内容， 来源链接： utcz.com/z/530870.html
