Python训练营02——数据结构、数据类型

本笔记为阿里云天池龙珠计划Python训练营的学习内容，链接为：

https://tianchi.aliyun.com/specials/promotion/aicamppython

---

学习内容与总结：

​
列表： 整型<class 'int'> 浮点型<class 'float'> 布尔型<class 'bool'> 容器数据类型 列表<class 'list'> 元组<class 'tuple'> 字典<class 'dict'> 集合<class 'set'> 字符串<class 'str'>

car=['3','audi','toyota']
print(car,type(car))
x=list(range(20,1,-3))#range(首,尾,步长)
print(x,type(x))
y=car*5#复制5次
print(y)
z=[i for i in range(100) if (i%2!=0) and (i%3)==0]
print(z)
['3', 'audi', 'toyota'] <class 'list'>
[20, 17, 14, 11, 8, 5, 2] <class 'list'>
['3', 'audi', 'toyota', '3', 'audi', 'toyota', '3', 'audi', 'toyota', '3', 'audi', 'toyota', '3', 'audi', 'toyota']
[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]
animal=[]
animal.append('cat')
animal.append([1])
animal.extend([1,2,'yanl'])#append是追加；extend是拓展
#list.extend(seq) 在列表末尾一次性
#追加另一个序列中的多个值（用新列表扩展原来的列表）
print(animal)
animal.insert(1,'fish')#在编号为1的位置插入fish;list.insert(index,obj)
print(animal)
animal.remove(1) #list.remove(obj)
print(animal)
##list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
#remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del animal[1:3] #删除index=1和index=2的obj
print(animal)
#如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；
#如果你要在删除元素后还能继续使用它，就使用方法pop()。
#切片 list[start:stop:step(默认为1)];若step=-1,则反向排列。这三个都可以不写
['cat', [1], 1, 2, 'yanl']
['cat', 'fish', [1], 1, 2, 'yanl']
['cat', 'fish', [1], 2, 'yanl']
['cat', 2, 'yanl']
列表常用操作符：

car=[1,2]
car2=[4,2,3]
car3=car+car2 #+是首尾拼接
car4=car*3 #*是复制拼接
print(car3)
print(car4)
[1, 2, 4, 2, 3]
[1, 2, 1, 2, 1, 2]
前面三种方法（append, extend, insert）可对列表增加元素，
它们没有返回值，是直接修改了原数据对象。
而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
num=car4.count(1)#统计obj出现的次数
#列表反向 car2.reverse()
car2.sort()#排序
print(num,car2)
3 [2, 3, 4]
元组tuple： 1.定义语法为：(元素1, 元素2, ..., 元素n);Python 的元组与列表类似.不同之处在于tuple被创建后就不能对其进行修改，类似字符串. 2.元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。 3.

x = (1, 10.31, 'python'), ['data', 11]#二维元组
print(x)
x[1][1]=8#元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，
#但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
print(x)
((1, 10.31, 'python'), ['data', 11])
((1, 10.31, 'python'), ['data', 8])
#解压元组：
#解压（unpack）一维元组（有几个元素左边括号定义几个变量）
t=(2,10.3,'alway')
(a,b,c)=t
print(a,b,c)#解压
2 10.3 alway
#字符串（包括空字符串）
string='yan liang'
print(len(string),type(string))
print('C:\\\same')#如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。
#\n 换行符
print(r'C:\\name')#原始字符串只需要在字符串前边加一个英文字母 r 即可。
9 <class 'str'>
C:\\same
C:\\name
字符串与元组具有不可修改性；从 0 开始 (和 Java 一样) 切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。 索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

print(string.title())
Yan Liang
lower() 转换字符串中所有大写字符为小写。 upper() 转换字符串中的小写字母为大写。 swapcase() 将字符串中大写转换为小写，小写转换为大写。

str2 = "DAXIExiaoxie"
print(str2.upper())  # DAXIEXIAOXIE
print(str2.swapcase())  # daxieXIAOXIE
DAXIEXIAOXIE
daxieXIAOXIE
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。 rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。

str2 = "DAXIExiaoxie"
print(str2.find('xi'))  # 5
print(str2.find('ix'))  # -1
print(str2.rfind('xi'))  # 9

###字符串还有很多其他函数
5
-1
9
字典： 序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。 字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。 那么如何快速判断一个数据类型 X 是不是可变类型的呢？两种方法： 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。 便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。

i='tring'
print(hash(i))#可被哈希，没有报错，是不可变类型
print(hash({1, 2, 3}))
5674892008221761118
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-89-e53275fe5e0d> in <module>
      1 i='tring'
      2 print(hash(i))#可被哈希，没有报错，是不可变类型
----> 3 print(hash({1, 2, 3}))

TypeError: unhashable type: 'set'
字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。

dict 内部存放的顺序和 key 放入的顺序是没有关系的。 dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。 字典 定义语法为 {元素1, 元素2, ..., 元素n}

其中每一个元素是一个「键值对」-- 键:值 (key:value) 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」 大括号 -- 把所有元素绑在一起 逗号 -- 将每个键值对分开 冒号 -- 将键和值分开

car={'benz':1998,'toyota':2001,'audi':2003}
print(car['audi'],type(car))#注意：如果我们取的键在字典中不存在，会直接报错KeyError。
2003 <class 'dict'>
dict() 创建一个空的字典。 通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入 value，后面的值会把前面的值冲掉。

trans=dict()  #事先声明一个字典
trans['car']='benz' #把数据放入字典中
trans['bike']='fenghuang'
trans['plane']='dongfang'
print(trans)
{'car': 'benz', 'bike': 'fenghuang', 'plane': 'dongfang'}
trans=dict(car=1898,bike=2005)
print(trans)
{'car': 1898, 'bike': 2005}
#字典的内置方法
#dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
seq = ('name', 'age', 'sex')
dic3 = dict.fromkeys(seq, ('小马', '8', '男'))
print(dic3)
key_dic=dic3.keys()# dict_keys(['Name', 'Age'])
print(list(key_dic))#转换为列表
print(dic3.get('age'))#返回键的值
{'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}
['name', 'age', 'sex']
('小马', '8', '男')
dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。 del dict[key] 删除字典给定键 key 所对应的值。

dict.clear()用于删除字典内所有元素。 可以查询字典的长度dict.len()

dict.copy()返回一个字典的浅复制。

dic1 = {1: "a", 2: [1, 2]}
print(dic1.pop(1), dic1)  # a {2: [1, 2]}

# 设置默认值，必须添加，否则报错
print(dic1.pop(3, "nokey"), dic1)  # nokey {2: [1, 2]}

del dic1[2]
print(dic1)  # {}
a {2: [1, 2]}
nokey {2: [1, 2]}
{}
集合： Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。 直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。 重复元素在set中会被自动被过滤。 注意，key为不可变类型，即可哈希的值。

num = {} print(type(num)) # <class 'dict'> num = {1, 2, 3, 4} print(type(num)) # <class 'set'>

car=set()#在创建空集合的时候只能使用s=set()，因为s = {}创建的是空字典。
print(type(car))
car.add('benz')
print(car)
<class 'set'>
{'benz'}
lst=[1,2,0,3,2,0,1,2]
a=set(lst)#使用set(value)工厂函数，把列表或元组转换成集合。
b=list(a)
print(b)#去掉了列表中重复的元素
[0, 1, 2, 3]
由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中。

print(len(a))
print(3 in a)#以通过in或not in判断一个元素是否在集合中已经存在
4
True
集合的内置方法： set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

a.add(6)#添加 a.remove(2)#移除

set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。 set.pop() 用于随机移除一个元素。

set.intersection(set1, set2) 返回两个集合的交集。 set1 & set2 返回两个集合的交集。 set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。 set.union(set1, set2) 返回两个集合的并集。 set1 | set2 返回两个集合的并集。 set.difference(set) 返回集合的差集。 set1 - set2 返回集合的差集。 set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。 set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

序列 序列类型包括字符串str、列表list、元组tuple、集合set和字典dict，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

max/min(sub)返回序列或者参数集合中的最大/小值

 

​