Python的变量与数据类型

     

        Python变量是用于存储数据的名称，它们是动态类型的，意味着你不需要指定变量类型，Python可以根据变量中存储的值自动推断出变量类型。常见的Python数据类型包括：

1. 数字(Number)：整型(int)、长整型(long)、浮点型(float)、复数(complex)。
2. 字符串(String)：用单引号(' ')、双引号(" ")等表示。
3. 列表(List)：用中括号([])表示的有序集合。
4. 元组(Tuple)：用小括号(())表示的有序集合，不可修改。
5. 字典(Dict)：用大括号({})表示的键值对集合。
6. 集合(Set)：用大括号({})或set()函数表示的无序不重复元素集合。

        使用Python内置的type()函数可以查看变量的数据类型，例如：

x = 10
print(type(x))  # 输出：<class 'int'>
 

---

1.数字（Number）

        Python中的数字类型有以下几种：

        1. 整型(int)：表示整数，例如：1、2、3、-4等。

a = 10
print(type(a))

#<class 'int'>

        2. 长整型(long)：用于表示超过普通整数取值范围的整数，例如：12345678901234L。但在Python3中取消了长整型的概念，普通整型(int)能够支持的取值范围已经很大了。

b = 12345678901234567890   # 需要使用长整型时，在数字后加L
print(type(b))

 # <class 'int'>

        3. 浮点型(float)：表示带有小数部分的实数，例如：1.23、3.14159等。

c = 3.14
print(type(c))

 # <class 'float'>

        4. 复数(complex)：表示一个实数和虚数部分，例如：1+2j、3.5+4j等。

d = 1+2j
print(type(d))

 # <class 'complex'>

2.字符串（String）

        在Python中，字符串是一种不可变的序列类型，表示由一系列字符组成的数据。可以使用单引号、双引号、三引号来表示字符串，如下所示：

str1 = 'Hello, World!'
str2 = "Python"
str3 = '''This is a multi-line string
with triple quotes.'''
 

        其中，第三种表示方式可以表示多行字符串，而不需要使用转义字符。字符串是序列类型，可以使用索引和切片来访问和操作，例如：

str1 = 'Hello, World!'
print(str1[0])

 # H，访问第一个字符
print(str1[-1])  

# !，访问最后一个字符
print(str1[0:5])

 # Hello，访问前5个字符

        字符串还支持一系列的操作，例如拼接、重复、查找、替换等等，具体可以参考Python官方文档。值得注意的是，在Python中字符串是不可变的，也就是说，无法直接修改一个字符串中的某个字符，但可以通过新建一个字符串并赋值的方式来实现字符串的修改，例如：

str1 = 'Hello, World!'
str1 = 'J' + str1[1:]
print(str1)  

# Jello, World!
 

        

3.列表（List）

        在 Python 中，列表是一种可变的序列类型，表示由一系列元素组成的数据。可以使用方括号来表示列表，例如：

list1 = [1, 2, 3, 4, 5]
list2 = ['apple', 'banana', 'orange']
list3 = [1, 'apple', True]
 

        列表中的元素可以是任意类型，甚至可以是另一个列表。列表也是序列类型，可以使用索引和切片来访问和操作，例如：

list1 = [1, 2, 3, 4, 5]
print(list1[0])  # 1，访问第一个元素
print(list1[-1])  # 5，访问最后一个元素
print(list1[2:4])  # [3, 4]，访问第3到第4个元素

list1[0] = 6  # 修改第一个元素
print(list1)  # [6, 2, 3, 4, 5]

list1.append(6)  # 在末尾添加一个元素
print(list1)  # [6, 2, 3, 4, 5, 6]
 

        列表支持一系列的操作，如求长度、拼接、重复、排序等等，具体可以参考Python官方文档。列表是可变的，也就是说，可以直接修改一个列表中的元素，或者添加、删除元素，例如：

list2 = ['apple', 'banana', 'orange']
list2[1] = 'pear'  # 修改第二个元素
print(list2)  # ['apple', 'pear', 'orange']

list2.append('kiwi')  # 在末尾添加一个元素
print(list2)  # ['apple', 'pear', 'orange', 'kiwi']

del list2[0]  # 删除第一个元素
print(list2)  # ['pear', 'orange', 'kiwi']
 

4.元组（Tuple）

        在 Python 中，元组是一种不可变的序列类型，和列表相似，但是元组中的元素不可以被修改，元组中的元素可以是任意类型，甚至可以是另一个元组。。可以使用小括号或者tuple()函数来表示元组，例如：

tuple1 = (1, 2, 3)
tuple2 = ('apple', 'banana', 'orange')
tuple3 = (1, 'apple', True)
 

        

                元组也是序列类型，可以使用索引和切片来访问和操作，例如：

tuple1 = (1, 2, 3)
print(tuple1[0])  # 1，访问第一个元素
print(tuple1[-1])  # 3，访问最后一个元素
print(tuple1[1:])  # (2, 3)，访问第2到最后一个元素

# 下面的代码会抛出 TypeError 异常，因为元组是不可变的
# tuple1[0] = 4
# del tuple1[0]
 

        由于元组是不可变的，因此不能直接修改元组中的元素，也不能添加、删除元素。元组支持一部分序列操作，如求长度、拼接、重复等等，但是不能执行排序等修改操作。元组一般用于表示一些不可变的数据结构，如一个点的坐标、一条线段的两个端点等等。

5.字典（Dict）

        在 Python 中，字典（Dictionary）是一种键值对的数据结构，可以用来存储和访问值，它是一种无序的容器，类似于我们现实世界的字典，其中每个单词都有一个对应的含义，我们可以通过单词来查找它的含义。字典中的键可以是任何不可变的数据类型，例如整数、浮点数、字符串、元组等。而值则可以是任何类型的数据，包括数字、字符串、列表、字典等。字典使用花括号 `{}` 或者 `dict()` 函数来表示，其中每个键值对之间用逗号 `,` 隔开，例如：

grades = {'math': 90, 'english': 86, 'history': 80}
 

        上面的代码定义了一个字典，其中 `'math'`、`'english'`、`'history'` 是字典的键，而 `90`、`86`、`80` 则是对应的值。

        我们可以通过键来访问字典中的值，例如：

print(grades['math'])  # 输出 90
 

        如果访问一个不存在的键，则会抛出 `KeyError` 异常。为了避免这种情况，我们可以使用 `get()` 方法来访问字典中的值，例如：

print(grades.get('science'))  # 输出 None
print(grades.get('science', 70))  # 输出 70
 

        上面的代码中，`get()` 方法会返回键 `'science'` 对应的值，但是由于字典中不存在这个键，因此返回 None。我们还可以提供一个默认值，如果键不存在，则返回默认值。

        除了访问值，我们还可以通过键来修改、添加、删除字典中的元素。例如：

# 修改
grades['math'] = 95
print(grades)  # {'math': 95, 'english': 86, 'history': 80}

# 添加
grades['science'] = 88
print(grades)  # {'math': 95, 'english': 86, 'history': 80, 'science': 88}

# 删除
del grades['history']
print(grades)  # {'math': 95, 'english': 86, 'science': 88}
 

        字典也支持一些常用的操作，如求长度、遍历键值对、获取键列表或值列表等等。字典是 Python 中非常常用的数据结构，尤其在数据处理和网络编程中。

6.集合（Set）

        在 Python 中，集合（Set）是一种无序的容器，用于存储不重复的元素，类似于数学中的集合概念，可以进行并集、交集、差集等运算。集合中的元素必须是不可变的数据类型，例如整数、浮点数、字符串、元组等，而不能包含列表、字典等可变类型。这是因为集合是基于哈希表实现的，需要保证元素的哈希值不变。

        集合使用花括号 `{}` 或者 `set()` 函数来表示，其中每个元素之间用逗号 `,` 隔开，例如：

fruits = {'apple', 'banana', 'orange'}
 

        上面的代码定义了一个集合，其中 `'apple'`、`'banana'`、`'orange'` 是集合的元素，由于集合是无序的，因此每次打印出来的顺序可能会不同。

        我们可以使用 `in` 操作符来判断一个元素是否在集合中，例如：

print('apple' in fruits)  # 输出 True
 

        我们还可以通过集合的方法来进行元素的增、删、改、查操作。例如：

fruits.add('pear')  # 添加一个元素
print(fruits)  # {'banana', 'pear', 'orange', 'apple'}

fruits.update(['grape', 'kiwi'])  # 添加多个元素
print(fruits)  # {'kiwi', 'banana', 'pear', 'grape', 'orange', 'apple'}

fruits.remove('banana')  # 删除一个元素
print(fruits)  # {'kiwi', 'pear', 'grape', 'orange', 'apple'}

fruits.discard('banana')  # 删除一个不存在的元素，不会抛出异常
print(fruits)  # {'kiwi', 'pear', 'grape', 'orange', 'apple'}

fruits.pop()  # 随机弹出一个元素
print(fruits)  # {'pear', 'grape', 'orange', 'apple'}
 

        除了常规的操作，集合还支持一些集合运算，如并集、交集、差集等。例如：

fruits1 = {'apple', 'banana', 'orange'}
fruits2 = {'banana', 'kiwi', 'mango'}

print(fruits1.union(fruits2))  # 并集 {'kiwi', 'banana', 'pear', 'orange', 'apple', 'mango'}
print(fruits1.intersection(fruits2))  # 交集 {'banana'}
print(fruits1.difference(fruits2))  # 差集 { 'pear', 'orange', 'apple'}
 

        集合是 Python 中非常实用的数据结构，它可以帮助我们快速判断元素是否存在，在数据处理和网络编程中也有广泛的应用。