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 = {}\nlist_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)：将一个整数转换为一个八进制字符串