Python数据类型

一、数据类型

        整形、浮点型、字符串、布尔类型、None、列表、元组、字典、集合

二、列表

        列表是一个可以包含任何数据类型的有序集合，比如数字、字符串甚至是其它列表。列表是可变的，也就是说可以改变一个列表的内容。

2.1、创建列表

        创建列表，只需要将一些值用逗号隔开，然后用方括号括起来即可。例如：

1、创建一个包含整数的列表
    numbers = [1,2,3,4]
2、创建一个包含字符串的列表
    fruits = ['apple','banana','cherry']

2.2、列表的索引

        列表中的每一个元素都有一个索引，这是一个标识元素在列表中位置的数字。在Python中，索引是从0开始的。我们可以使用索引来访问列表中的特定元素

        索引也支持负索引，它从列表的末尾开始计数，-1表示最后一个元组，-2表示倒数第二个元素

示例如下：

例1：
    fruits = ['apple','banana','cherry']
	print(fruits[0])   #输出apple
	print[fruits[1]]   #输出banana
例2：
    
    fruits = ['apple','banana','cherry']
	print(fruits[-1])    #输出：cherry
	print(fruits[-2])    #输出：banana

2.3、修改列表

        由于列表是可变的，我们可以使用索引来修改列表中的元素。

例如：

fruits = ['apple','banana','cherry']
fruits[1] = 'blueberry'
print(fruits)    #输出:['apple','blueberry','cherry']

         此外，我们可以使用列表的append方法添加新元素，使用remove方法删除元素，使用insert方法在特定的位置插入元素

fruits = ['apple','banana','cherry']
fruits.append('date')
print(fruits)    #输出['apple','banana','cherry','date']
			
fruits.remove('banana')
print(fruits)    #输出：['apple','cherry','date']
			
fruits.insert(1,'banana')
print(fruits)    #输出:['apple','banana','cherry',date]

2.4、列表的切片操作

        切片是一种获取列表子集的操作。通过指定开始索引和结束索引，我们可以获得列表的一部分。需要之一的是切片操作是左闭右开的，也就是说，他会包含开始索引的元素，但是不包含结束索引的元素

numbers = [0,1,2,3,4,5,6,7,8,9]
print(number[:5])    #输出：[0,1,2,3,4]
print(number[5:])    #输出：[5,6,7,8,9]

2.5、排序

        列表提供了两种排序方式，sort和sorted。sort方法会直接修改原列表，使其变为有序状态；二sorted函数则会返回一个新的排序列表，原列表保持不变

numbers = [4,2,9,7,5,1]
number.sort()
print(numbers)    #输出：[1,2,4,5,7,9]
			
numbers = [4,2,9,7,5,1]
new_numbers = sorted(numbers)
print(new_numbers) #输出:[1,2,4,5,7,9]
print(numbers)  #输出：[4,2,9,7,5,1]

2.6、列表的长度

        可以使用python的内建函数len来获取列表的长度

fruits = ['apple','banana','cherry']
print(len(fruits))     #输出3

三、元组

        元组(tuple)是python中另一种内置的存储有序数据的结构。

        元组与列表类似，也是一系列按特定顺序排列的元素组成，可存储不同类型的数据，然而元组是不可该表的，创建后不再做任何修改操作

3.1、元组的创建

        使用赋值语句可直接创建元组，需要注意的是列表使用的是方括号，元组使用的是小括号

tuplename = (元素1,元素2,元素3,元素4,....元素n)

         在python中，可以创建空元组，空元组可以应用在为函数传递一个空值或者返回空值时。

3.2、range()

        可以使用tuple()函数将range()函数循环出来的结果转换为数值元组

data = range(1,11)    #range函数左闭右开
tuplename = tuple(data)
print(tuplename)    #输出(1,2,3,4,5,6,7,8,9,10)

3.3、删除元组

        元组中的元素值不允许被修改，但是我们可以使用del语句删除整个元组。对于已经创建的元组，不再使用时，可以使用del语句将其删除。

data = range(1,11)
tuplename = tuple(data)
del tuplename
print(tuplename)   #输出报错，因为tuplename元组已经被删除

3.4、修改元组元组

        元组是不可变序列，所以不能对它的单个元素值进行修改，但是可以对元组重新赋值

data = range(1,11)
tuplename = tuple(data)
tuplename = (1,2)
print(tuplename)  #输出：(1,2)

3.5、常见的元组操作

len(tup)：返回元组中元素的个数；

min(tup)：返回元组中元素最小的值；

max(tup)：返回元组中元素最大的值；

tuple(seq)：将列表转化为元组

3.6、元组与列表的区别

        列表内的元素可以被随时修改或删除，元组不可以；

        元组比列表的访问和处理速度快；

        列表不能作为字典的键，元组可以

3.7、元组的切片

tuples = (1,2,3,4)
print(tuples[:2]

3.8、元组与列表的相互转换

tuple()函数接收一个列表，返回一个包含相同元素的元组；

list()函数接收一个元组，返回一个列表

四、字典

        字典是一种无序、可变的数据类型，用于存储键和值之间的映射关系。字典是一种高效的数据结构，可以用于快速查找和检索数据。

4.1、创建字典

        可以使用大括号{}或者dict()函数来创建一个字典。字典中的键是唯一的，且必须是不可变的(例如字符串、数字、元组，列表就不可以做键)。而值可以是任意类型的对象。

以下几种方法创建的字典均等于{"one":1,"two":2,"three":3}
    dict(one=1,two=2,three=3)
    {'one': 1, 'two': 2, 'three': 3}
	dict(zip(['one', 'two', 'three'], [1, 2, 3]))
	dict([('two', 2), ('one', 1), ('three', 3)])
	dict({'three': 3, 'one': 1, 'two': 2})
	dict({'one': 1, 'three': 3}, two=2)

总结：以下是创建字典的几种方式

 

1、使用大括号创建

                     my_dict = {}

2、使用dict()函数创建

                     my_dict = dict(key1=value1,key2=value2,key2=value3)

3、从列表创建字典，列表中的元素是由键值对组成的元组

                     my_dict = dict([(key1,value1),(key2,value2),(key3,value3)])

4.2、访问字典中的值

        可以使用方括号来访问字典中的值，将键作为索引传递给字典即可获取对应的值

my_dict = {'name':'Alice','age':25,'city':'New York'}
print(my_dict['name']   #输出：Alice

        如果访问不存在的键，会触发KeyError异常，可以使用get()方法来避免异常，如果键不存在，get()方法会返回指定的默认值 

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(my_dict.get('name'))         # 输出: Alice
print(my_dict.get('gender', 'N/A')) # 输出: N/A，键'gender'不存在，返回默认值'N/A'

4.3、修改字典

        字典的值是可变的，可以通过键来修改字典中的值

my_dict = {'name':'admin','age':25,'city':'shanghai'}
my_dict['age'] = 10  #修改键'age'对应的值为10
print(my_dict)   #输出{'name':'admin','age':10,'city':'shanghai'}

         如果键不存在，赋值操作将会创建一个新的键值对

4.4、删除字典元组

        可以使用del关键字来删除字典中的元素，通过指定要删除的键来完成删除操作

my_dict = {'name':'admin','age':25,'city':'shanghai'}
del my_dict['age']   #删除键'age'及其对应的值
print(my_dict)    #删除{'name':'admin','city':'shanghai'}

        如果删除不存在的键，会触发KEyError异常，可以使用pop()方法来删除键，并返回对应的值，如果键不存在，pop()方法会返回指定的默认值

my_dict = {'name':'admin','age':25,'city':'shanghai'}
removed_age = my_dict.pop('age')    #删除键'age'及其对应的值，并返回被删除的值
print(removed_age)    #输出25
removed_gender = my_dict.pop('gender','N/A')    #键'gender'不存在，返回默认值'N/A'
print(removed_gender)    #输出：N/A

         还可以使用popitem()方法删除字典中的最后一个键值对，并返回被删除的键值对

4.5、字典的常用操作

4.5.1、遍历字典

        可以使用for循环遍历字典的键或值，或者同时遍历键和值

遍历键
    my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
    for key in my_dict:
        print(key)  # 输出: name, age, city

遍历值
    for value in my_dict.values():
        print(value)  #输出: Alice, 25, New York

遍历键和值
    for key,value in my_dict.items():
        print(key,value)  #输出: name Alice, age 25, city New York

4.5.2、检查键是否存在

        可以使用in关键字来检查某个键是否存在于字典中

	print('name' in my_dict)    #输出：true
	print('gender' in my_dict)    #输出：false

4.5.3、获取字典长度

        用len()函数来获取字典的长度，也就是键值对的数量

length = len(my_dict)
print(lengtg)  #输出：3

4.5.4、其它常用方法

clear()：清空字典中的所有键值对；

copy()：创建字典的副本(浅拷贝)：
new_dict = my_dict.copy()
print(new_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

update()：将一个字典的键值对更新到另一个字典中
my_dict = {'name': 'Alice', 'age': 25}
new_data = {'city': 'New York', 'gender': 'female'}
my_dict.update(new_data)
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'female'}

keys()：返回一个包含字典所有键的试图(类似于列表)
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['name', 'age', 'city'])

values()：返回一个包含字典所有值的试图(类似于列表)
items()：返回一个包含字典所有键值对的试图(类似于列表中的元组)

五、集合

        集合用于保存不重复的元素，有可变集合(set)和不可变集合(frozenset)两种。在形式山，集合的所有元素都放在一堆大括号中，两个相邻元素间使用逗号分隔。集合最好的应用就是去重，因为集合中的每一个元素都是唯一的。

5.1、集合的创建

        在python中提供了两种创建集合的方法，一种是直接使用{}创建，一种是通过set()函数将列表、元组等可迭代对象转换为集合

1、collection = {1,2,3,4,5}
2、lists = [1,2,3,4,5]
    collection = set(lists)

5.2、集合常见的元素操作

1、add()：向集合中添加元素；
2、update()：向集合追加的数据是序列；
3、del命令删除整个集合；
4、discard()方法、pop()方法、remove()方法：删除一个元素；
5、clear()：清空集合；
6、in：判断数据在集合中；
7、not in：判断数据不在集合中；
8、set(list)：将列表转换为集合

	集合是可修改的数据类型，但集合中的元素必须是不可修改的，也就是说集合中的元素只能是数值、字符串、元组之类
	集合最常用的操作就是进行交集、并集、差集和对称差集运算
	交集：
		collection_01 = {1,2,3}
		collection_02 = {1,2}
		print(collection_01 & collection_02)  #输出：{1,2}
	并集
		collection_01 = {1,2,3}
		collection_02 = {1,2,4}
		print(collection_01 | collection_02)  #输出：{1,2,3,4}
	差集
		collection_01 = {1,2,3}
		collection_02 = {1,2,4}
		print(collection_01 - collection_02)  输出：{3}，注意是集合01对02的差集，如果是02对01，则输出{4}