Python的基本操作——1.2. 数据类型

学习视频来自麦子学院

一、 Python数据类型——数值类型

1. 总体：numeric/sequences/mappings/classes/instances/exceptions

2. 数值型： int（包含boolean）, float, complex（直接支持复数）

3. int 类型：不限制长度

    float类型：对应C中double

    complex复数类型： real & imaginary，用z. real或 z.imag来取实部和虚部

4. 运算实例

运算符号：+、-、*、/、//（向下取整）

python是一个动态语言，可以不需要事先声明变量类型。

import sys
a=3
b=4
c=5.1
d=6.1

e=complex(c,d) #构造复数
f=complex(float(a),float(b))

print(a)
print(e)
print(f)

二、数据结构——列表list

1.  很像数组，索引从0开始，中括号括着

2.  包含的元素：int\float\string、混合型

3.  各种操作：

创建、访问、更新、删除、脚本操作符、函数方法

# 创建list
number_list=[1,2,3,4]        #int型的list
string_list=["ab","aba","ccc"]  #字符串型
mixed_list=["ab",1,12]      #混合型
print("the number list:"+str(number_list))

# 访问list中的值
first_number=number_list[0]
print(first_number)

# 更新列表
number_list[2]=110
print("更新之后的列表："+str(number_list))

# 删除元素
del number_list[2]
print("删除列表元素后："+str(number_list))

# 脚本语言
print(len(number_list)) # 长度：3
print([1,2,3]+[4,5,6]) # 组合：[1, 2, 3, 4, 5, 6]
print(["hello"]*4) # 重复：['hello', 'hello', 'hello', 'hello']
print(3 in [1,2,3]) # 某元素是否在列表中：True

# 列表的截取
abcd_list=['a','b','c','d']
print(abcd_list[1]) # 输出列表第二个元素：b
print(abcd_list[-2]) # 输出列表从右边数的第二个元素：c
print(abcd_list[1:]) # 将列表第1-end之间的元素截取成新list：['b', 'c', 'd']

# 函数方法
# 1. cmp(list1,list2):这个函数现在已经被取消了
# 2. len(list)：列表长度
# 3. max(list)：最大值
# 4. min(list)：最小值
# 5. list(seq)：将元组转化为list

# 列表的操作包含以下方法
# 1. list.append(obj)：在列表末尾追加新的对象
# 2. list.count(obj)：统计某个元素在列表中的出现次数
# 3. list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值
# 4. list.index(obj)：从列表中找出某个值第一次出现的索引位置
# 5. list.insert(index,obj)：在index处插入新对象
# 6. list.pop(obj=list[-1])：按索引位置移除列表中的某个元素（默认是最后一个-1），并返回该元素
# 7. list.remove(obj)：移除列表中某个值得第一个匹配项
# 8. list.reverse()：将列表反向排列
# 9. list.sort([func])：对原列表进行排序

三、数据结构——元组tuple

1. 创建、访问、删除、脚本操作符、函数方法

    为什么没有写更新呢？因为元组的特性：不可更改——但是元组中的list的值可以改

    同样原因，不可以删去其中的一个元素，但是可以把整个tuple删掉

# 创建tuple
number_tuple=(1,2,3)
num_tuple=(1,) # !!!如果只有一个元素时，要加一个,区别
string_tuple=("aa","bb","cc")
mixed_tuple=(1,2,["a","b"])

# 访问，同list的访问一样，中括号内加索引
first_obj=number_tuple[0]
print(first_obj) #1

# 更新：tuple一旦创建不可更改，但可以更新tuple中list内的值
mixed_tuple[2][1]="c"
print("更新之后的tuple："+str(mixed_tuple)) #更新之后的tuple：(1, 2, ['a', 'c'])

# 删除：tuple一旦创建不可更改、删除，但可以删除整个tuple
del mixed_tuple

# 脚本语言
print(len(number_tuple)) # 长度：3
print((1,2,3)+(4,5,6)) # 组合：[1, 2, 3, 4, 5, 6]
print(("hello")*4) # 重复：hellohellohellohello
print(3 in (1,2,3)) # 某元素是否在tuple中：True

# tuple的截取
abcd_tuple=('a','b','c','d')
print(abcd_tuple[1]) # 输出列表第二个元素：b
print(abcd_tuple[-2]) # 输出列表从右边数的第二个元素：c
print(abcd_tuple[1:]) # 将列表第1-end之间的元素截取成新tuple：('b', 'c', 'd')

2. tuple与list的区别

（1）当创建只有一个元素的tuple时，要在元素后加一个逗号消除歧义，而list不用

（2）tuple可以看做是不可变list，一旦创建了就不可以更改，但如果tuple中有list，可以通过索引更改list中的元素值。

（3）【同】定义tuple和list的方式相同，除了两头用的是方括号还是圆括号

tuple的元素和list的一样，按定义的顺序排序，索引均从0开始，负索引从尾部开始。

可以和list一样分片(slice)也可以使用，分割后分别得到一个新的list和新的tuple

（4）【异】tuple中没有：append（尾部增加元素）、remove等改变结构的方法。但可以用in来检查一个元素是否在tuple中

（5）tuple的好处：操作速度比list快，适用于不经常改变的集合。如同有了”写保护“，如果一定要改变tuple的值，就要将其转换为list

（6）tuple和list可以相互转换

# tuple和list相互转换
list1=[1,2,3]
tuple1=tuple(list1)
print(tuple1) # 就像强制类型转换一样，结果：(1, 2, 3)

（7）tuple的特殊用法：一次赋多值

# tuple的特殊用法：一次赋多值
v=('a','b','c')
(x,y,z)=v
print((x,y,z)) #result:('a', 'b', 'c')
print(x) #result:a

四、数据结构——字典dictionary

1. 键（key），对应值（value），成对出现的

2. 操作：创建、访问、更新、删除

# 创建字典
phone_book={"Tom":123,"Amy":789}
mixed_dict={"Tom":"boy",11:12.5}

# 访问
number=phone_book["Tom"]
print("Tom's number is "+str(phone_book["Tom"]))

# 更新
phone_book["Tom"]=999
print("Tom's number is "+str(phone_book["Tom"])) #Tom's number is 999

# 新增
phone_book["Mary"]=666
print("Mary's number is "+str(phone_book["Mary"])) #Mary's number is 666

# 删除-元素
print("phone book before del: "+str(phone_book)) #phone book before del: {'Tom': 999, 'Amy': 789, 'Mary': 666}
del phone_book["Mary"]
print("phone book after del: "+str(phone_book)) #phone book after del: {'Tom': 999, 'Amy': 789}
phone_book.clear()
print("phone book after clear: "+str(phone_book)) #词典还存在，只是清空了：phone book after clear: {}
del phone_book

3. 特性

（1）每个key都必须是独一无二，不能重复的。即使有两个一样的key，程序部报错，但只当做一个key来处理

（2）key必须是不可变的，所以可以是数、字符串、元组，不可以是list

4. 字典内置函数&方法

# 内置函数
# 1. cmp(dict1,dict2)：比较两个字典的元素，现在已经取消了哦
# 2. len(dict)：字典元素个数！！键的总数
# 3. str(dict)：将字典转化为字符串表示
# 4. type(dict)：返回输入变量类型
# 内置方法
# 1. dict.clear()：清空字典
# 2. dict.copy()：返回一个字典的浅复制
# 3. dict.fromkeys()：创建一个新字典，以seq中的元素作为键，对应的value是所有键对应的初始值
# 4. dict.get(key,default=None)：返回指定键的值，如果不在字典中，就返回default的值
# 5. dict.has_key(key)：如果字典中有这个键，返回true
# 6. dict.items()：以列表形式返回可以遍历的（键、值）元组数组:dict_items([('Tom', 999), ('Amy', 789), ('Mary', 666)])
# 7. dict.keys()：以列表形式返回所有键
# 8. dict.values()：以列表形式返回字典中所有的值
# 9. dict.setdefault(key,default=None)：如果没有这个键，则创建这个键，value的值就是default的值
# 10. dict.update(dict2)：把dict2中的键值对复制到dict中