[GN] Python3基本数据类型 -- 与C的差异

---

Python3 面向对象

---

Python3的基本数据类型

6个标准的数据类型

Numbers（数字）; String（字符串）; List（列表）; Tuple（元组）; Set（集合）; Dictionaries（字典）

Numbers

1. 类型

int
float
boll
complex(复数) 4+3j

2. 数值运算

2//4 除法 一个整数

2/4 除法 一个浮点数

2**5 乘方

String

1. \ 转义特殊字符

>>> print('C:\some\name')
C:\some
ame
>>> print(r'C:\some\name')
C:\some\name

2. 可以使用+ *连接

>>> print('str'+'ing', 'my'*3)
string mymymy

3. 可以对字符串切边（前闭后开）

>>> word = 'ilovepython'
>>> word[1:5]
'love'
>>> word[:]
'ilovepython'
>>> word[5:]
'python'
>>> word[-10:-6]
'love'

4. 与C字符串不同，Py字符串不能改变

word[0] = 'm'  #这是错误的

List

1. 写在方括号之间，列表元素类型可以不同

>>> a = ['him', 25, 100, 'her']
>>> print(a)
['him', 25, 100, 'her']

2. 可以使用+ 连接

>>> a = [1, 2, 3, 4, 5]
>>> a + [6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

tuple

1. 写在圆括号之间，与列表相似，不同在于元组的元素不能改变

>>> a = (1991, 2014, 'physics', 'math')
>>> print(a, type(a), len(a))
(1991, 2014, 'physics', 'math') <class 'tuple'> 4

2. 构造包含0或1个元素的元组的特殊语法规则

tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

3. 元组也可以使用+ 操作符

Sets

1. 是一个无序不重复元素的集合（可用来成员关系测试和消除重复元素）；可以使用大括号 或者 set()函数创建集合

>>> student = ()     #创建空集合
>>> student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
>>> print(student)   # 重复的元素被自动去掉
{'Jim', 'Jack', 'Mary', 'Tom', 'Rose'}
>>> 'Rose' in student  # membership testing（成员测试）
True
>>> # set可以进行集合运算
... 
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'b', 'c', 'd', 'r'}
>>> a - b     # a和b的差集
{'b', 'd', 'r'}
>>> a | b     # a和b的并集
{'l', 'm', 'a', 'b', 'c', 'd', 'z', 'r'}
>>> a & b     # a和b的交集
{'a', 'c'}
>>> a ^ b     # a和b中不同时存在的元素
{'l', 'm', 'b', 'd', 'z', 'r'}

Dictionaries

1. 字典是一种映射类型，他是一个无序的键值对集合。 关键字key必须是不可变类型（也就是说list和包含可变类型的tuple不能是关键字）

>>> dic = {}  # 创建空字典
>>> tel = {'Jack':1557, 'Tom':1320, 'Rose':1886}
>>> tel
{'Tom': 1320, 'Jack': 1557, 'Rose': 1886}
>>> tel['Jack']   # 主要的操作：通过key查询
1557
>>> del tel['Rose']  # 删除一个键值对
>>> tel['Mary'] = 4127  # 添加一个键值对
>>> tel
{'Tom': 1320, 'Jack': 1557, 'Mary': 4127}
>>> list(tel.keys())  # 返回所有key组成的list
['Tom', 'Jack', 'Mary']
>>> sorted(tel.keys()) # 按key排序
['Jack', 'Mary', 'Tom']
>>> 'Tom' in tel       # 成员测试
True
>>> 'Mary' not in tel  # 成员测试
False

2. 构造函数可以直接从键值对swquence中构造字典

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'jack': 4098, 'sape': 4139, 'guido': 4127}>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}>>> dict(sape=4139, guido=4127, jack=4098)
{'jack': 4098, 'sape': 4139, 'guido': 4127}

Python运算符

逻辑 运算符

and; or; not

成员运算符

in; not in

身份运算符

is 两个标识符是不是引用自一个对象

is not 两个标识符不是引用自不同一个对象

Python3 数字

​​​​​​

Python3 序列

序列类型包括 字符串、列表、元组、集合和字典。（集合和字典不支持索引、切片、相加和相乘操作）

序列切片

访问一定范围内的元素

sname[start : end : step]

• sname: 序列名称
• start: 索引开始位置（包括该位置
• end: 结束索引位置（不包括该位置）
• step：隔几个存储位置

str=""
#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:2])
#隔 1 个字符取一个字符，区间是整个字符串
print(str[::2])
#取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])

序列相加

序列相乘

序列相关内置函数

Python3 列表

列表的数据项不需要有相同类型

list1 = ['Google', '', 1997, 2000]

访问列表的值

索引	0	1	3
负索引	-4	-3	-1
值	‘Google’	‘’	2000

更新列表

list1[2] = "1998" #直接对想要修改的数据项赋上一个新值即可修改该数据项
print ("list1的第三个元素为: ", list1[2])
list1.append(2021) #append()可以在列表后追加一项列表项
print ("追加列表项后的list1: ", list1)list1的第三个元素为:  1998
追加列表项后的list1:  ['Google', '', '1998', 2000, 2021]

删除列表元素

1. del删除

del list1[0] #del可以删掉一个元素
print ("删除列表项后的list1: ", list1)删除列表项后的list1:  ['', 1997, 2000]

2. remove删除

list1 = ['Google', '', 'Taobao', 'Baidu']
list1.remove('Taobao') # remove可以按值查找列表中的元素并删除
print ("列表现在为 : ", list1)
list1.remove('Baidu')
print ("列表现在为 : ", list1)列表现在为 :  ['Google', '', 'Baidu']
列表现在为 :  ['Google', '']

拼接列表

+号直接

嵌套列表

>>>a = ['a', 'b', 'c'] 
>>> n = [1, 2, 3] 
>>> x = [a, n] 
>>> x [['a', 'b', 'c'], [1, 2, 3]] 
>>> x[0] ['a', 'b', 'c'] 
>>> x[0][1] 'b'

列表函数方法

Python3 元组

元组使用小括号（）； 列表使用方括号[]

list1 = ('Google', '', 1997, 2000)

访问元组的值

索引	0	1	3
负索引	-4	-3	-1
值	‘Google’	‘’	2000

修改元组

元组中的元素值不允许修改。但可以连接

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。
# tup1[0] = 100# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)

删除元组元素

元组中的元素值不允许删除。但可以使用del删除整个元组

1. del删除

tup = ('Google', '', 1997, 2020)print (tup)
del tup;

元组内置函数

Python3 字典

dict = {key1 : value1, key2 : value2 }

键是唯一的，不可变的（如字符串，数字，元组）

访问字典的值

dict = {'Name': '', 'Age': 7, 'Class': 'First'}print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

修改字典

dict = {'Name': '', 'Age': 7, 'Class': 'First'}dict['Age'] = 8;               # 更新 Age
dict['School'] = "教程"  # 添加信息

删除字典元素

dict = {'Name': '', 'Age': 7, 'Class': 'First'}del dict['Name'] # 删除键 'Name'
dict.clear()     # 删除字典
del dict         # 删除字典print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

字典内置函数

Python3 集合

集合是一个无序的不重复元素序列

创建可以使用{} 或者 set()；但创建空的必须是set();

1. 集合创建

parame = {value01,value02,...}
或者
set(value)

2. 集合运算

a = set('abracadabra')
b = set('alacazam')print(a)
print(b)print(a-b)print(a|b)print(a&b)print(a^b){'b', 'd', 'a', 'c', 'r'}
{'l', 'z', 'm', 'a', 'c'}
{'r', 'd', 'b'}
{'l', 'z', 'b', 'm', 'd', 'a', 'c', 'r'}
{'c', 'a'}
{'l', 'z', 'b', 'm', 'r', 'd'}

集合的基本操作

1. 添加元素

s.add(x)
s.update( x ) #x可以是多个thisset = set(("Google", "", "Taobao"))
thisset.update({1,3})
print(thisset)
thisset.update([1,4],[5,6])  
print(thisset){1, 3, '', 'Taobao', 'Google'}
{1, 3, 4, 5, 6, '', 'Taobao', 'Google'}

2. 移除元素

s.remove( x )  #元素不存在会发生错误
s.discard( x ) #元素不存在不会发生错误

3. 计算集合元素个数

len(s)

4. 清空集合

s.clear()

5. 判断是否存在

x in s

集合内置函数

---