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

野性酷女 2021-09-27 03:56 341阅读 0赞

## 学习视频来自麦子学院 ##

## 一、 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中