Python基本数据类型及基本运算

刺骨的言语ヽ痛彻心扉 2022-08-28 09:47 291阅读 0赞

# Python基本数据类型及基本运算 #

### 文章目录 ###

*  Python基本数据类型及基本运算
 *   *  一、注释
     *  二、基本数据类型
     *  三、不同类型的转换
     *  四、对字符串的操作
     *  五、对列表的操作
     *  六、对元组的操作
     *  七、对字典的操作
     *  八、对集合的操作
     *  九、基本运算符

## 一、注释 ##

**单行注释：**

Python中单行注释以 `#` 开头，例如：

# 这是一个注释

**多行注释：**

Python中多行注释用三个单引号 `'''` 或者三个双引号 `"""` 将注释括起来，例如:

''' 这是多行注释，用三个单引号 这是多行注释，用三个单引号 这是多行注释，用三个单引号 '''
    
    """ 这是多行注释，用三个双引号 这是多行注释，用三个双引号 这是多行注释，用三个双引号 """

## 二、基本数据类型 ##

**总结：**

![image-20210920103240035][]

*  Python中创建变量不需要首先定义变量类型
 *  查看变量的数据类型使用函数 `type(x)`
 *  列表、元组、集合中可以存放不同类型的元素
 *  Pyhton3中没有长整型，增加了复数类型 `complex`
    
     *  把形如 `z = a + bj` 的数称为复数，a 为实部，b 为虚部，j 为虚数单位
     *  获取实部使用函数 `x.real`，获取虚部使用函数 `x.imag`，获取对应的共轭复数使用函数 `x.conjugate()`

**举例：**

# 整数
    a = 10
    print(type(a))  # <class 'int'>
    
    # 浮点数
    b = 3.18
    print(type(b))  # <class 'float'>
    
    # 字符串
    c = "gaoqize"
    print(type(c))  # <class 'str'>
    
    # 列表
    # 可以同时包含不同的类型
    d = ["1", 2.3, 3]
    print(type(d))  # <class 'list'>
    
    # 元组
    e = ("python", 12, 2.3)
    print(type(e))  # <class 'tuple'>
    
    # 字典
    f = { "key1":"v1", "key2":"v2"}
    print(type(f))  # <class 'dict'>
    
    # 集合
    g = { "python", 12, 2.3}
    print(type(g))  # <class 'set'>
    
    # 布尔型
    h = True
    print(type(h))  # <class 'bool'>
    
    # 复数
    i = 1 + 2j
    j = 2 + 5j
    print(type(i))  # <class 'complex'>
    print(i + j)  # (3+7j)
    print(i - j)  # (-1-3j)
    print(i * j)  # (-8+9j)
    print(i.real)  # 1.0
    print(i.imag)  # 2.0
    print(i.conjugate())  # (1-2j)

## 三、不同类型的转换 ##

类型 (变量) 即可将变量转换成对应的类型。

**字符串与整型互转**

a = 10
    var1 = str(a)  # 整数转换成字符串
    var2 = int(var1)  # 字符串转换成整数
    print(type(var1))  # <class 'str'>
    print(type(var2))  # <class 'int'>
    
    print(var1)  # 10
    print(var2)  # 10

**整型与浮点型互转**

a = 3.18
    var1 = int(a)  # 浮点数转换成整数
    var2 = float(var1)  # 整数转换成浮点数
    print(type(var1))  # <class 'int'>
    print(type(var2))  # <class 'float'>
    
    print(var1)  # 3
    print(var2)  # 3.0

注意：

1.  浮点数转换成整数采用的是去掉小数点的方式
2.  使用 `round()` 函数四舍五入取对应的小数位数，如：
    
        var1 = round(2.366, 2)  # 对2.366采用四舍五入的方式保留2位小数
        print(var1)  # 2.37

**列表和元组互转**

d = ["1", 2.3, 3]
    var1 = tuple(d)  # 列表转换成元组
    var2 = list(var1)  # 元组转换成列表
    print(type(var1))  # <class 'tuple'>
    print(type(var2))  # <class 'list'>
    
    print(var1)  # ('1', 2.3, 3)
    print(var2)  # ['1', 2.3, 3]

**嵌套元组转换成字典**

e = (("name", "gaoqize"), ("sex", "man"))  # 嵌套元组，如果要转换成字典，被嵌套元组只能含有2个元素
    var1 = dict(e)  # 嵌套元组转换成字典
    print(type(e))  # <class 'tuple'>
    print(type(var1))  # <class 'dict'>
    
    print(e)  # (('name', 'gaoqize'), ('sex', 'man'))
    print(var1)  # {'name': 'gaoqize', 'sex': 'man'}

**不同进制互相转换**

![image-20210920154255846][]

**举例：**

x 必须是字符串类型

其余进制想要转换成除10进制之外的进制，都必须要先转换成10进制

`int("x", 2)` 表示2进制的x转换成对应的10进制

`bin(int("x", 8))` 表示8进制的x转换成对应的2进制

print(int("1000", 2))  # 8print(bin(int("8", 10))) # 0b1000

## 四、对字符串的操作 ##

Python中的字符串支持单引号、双引号、三引号（支持多行字符串）（Java只支持双引号）

**定义字符串**

var1 = 'str1'
    var2 = "str2"
    var3 = '''line1 line2'''
    
    print(var1, var2, var3)
    ''' str1 str2 line1 line2 '''

**拼接字符串**

使用 “+” 号进行拼接

var1 = 'str1'
    var2 = "str2"
    
    print(var1 + var2)  # str1str2

**复制多个字符串**

字符串 \* 次数

var1 = 'str1' * 10
    print(var1)  # str1str1str1str1str1str1str1str1str1str1

**分割字符串split**

*  默认情况下，会对空格进行分割（多个空格当作一个空格进行分割）
 *  参数中指定要分割的字符

var2 = "str1 str2 str3 str4str5"
    print(var2.split())  # ['str1', 'str2', 'str3', 'str4str5']
    print(var2.split(' '))  # ['str1', 'str2', '', 'str3', '', '', 'str4str5']
    
    var3 = "str1:str2:str3:str4"
    print(var3.split(':'))  # ['str1', 'str2', 'str3', 'str4']

**替换字符串replace**

var4 = "I love Python"
    print(var4.replace("Python", "Java"))  # I love Java
    print(var4)  # I love Python，也就是说原字符串并没有发生改变

**字符串大小写转换**

var5 = "GAOQIZE"
    print(var5.upper())  # GAOQIZE
    print(var5.lower())  # gaoqize
    print(var5.capitalize())  # Gaoqize，让首字母大写，其余字母小写

**列表转换成字符串**

使用 `join` 函数完成列表转换成字符串的操作，注意要声明列表中的元素通过哪个字符连接在一起

var6 = ["I", "love", "u"]
    
    # 列表中的元素通过","进行拼接
    print(",".join(var6))  # I,love,u

## 五、对列表的操作 ##

*  拼接列表和复制多个列表的具体操作与字符串一致。
 *  列表也可以嵌套，如 `list1 = ["hello", 12, 12.8, ["hi", 22]]`

**通过索引访问列表元素**

类似数组，直接使用索引即可访问对应的元素。

从前向后访问索引位置从0开始，从后往前访问索引位置从-1开始。

list1 = ["hello", 12, 12.8, ["hi", 22]]
    print(list1[0])  # hello
    print(list1[-1])  # ['hi', 22]

**通过分片访问列表元素**

索引的位置使用 `[x:y]` 的格式，注意是左闭右开。

`[x:]` 表示x位置之后的所有元素（包括x），`[:y]` 表示y位置之前的所有元素（不包括y）。

list1 = ["hello", 12, 12.8, ["hi", 22]]
    print(list1[0:2])  # ['hello', 12]
    print(list1[-3:-1])  # [12, 12.8]
    print(list1[0:])  # ['hello', 12, 12.8, ['hi', 22]]
    print(list1[:3])  # ['hello', 12, 12.8]

**等步长访问列表元素**

使用 `[::x]` 表示先访问第一个元素，然后依次访问下一个步长为x的元素。

list1 = ["hello", 12, 12.8, ["hi", 22]]
    print(list1[::3])  # ['hello', ['hi', 22]]
    print(list1[::1])  # ['hello', 12, 12.8, ['hi', 22]]
    print(list1[::2])  # ['hello', 12.8]

**增加列表元素**

使用 `append()` 向列表尾部添加单个元素。

list1 = ["hello"]
    list1.append("你好")
    print(list1)  # ['hello', '你好']

使用 `extend()` 向列表尾部添加一个列表。

list1 = ["hello", 12, 12.8]
    list2 = ["more"]
    list1.extend(list2)
    print(list1)  # ['hello', 12, 12.8, 'more']

注意：使用 `append()` 添加元素会创建一个新的列表，使用 `extend()` 添加元素是在原列表的基础上添加。

使用 `insert()` 向列表指定位置添加一个元素。

list1 = ["hello", 12, 12.8]
    list1.insert(0, "first")  # 在0位置插入一个元素
    print(list1)  # ['first', 'hello', 12, 12.8]

**删除列表中的元素**

使用`del list[x]` 删除索引位置为x的元素。

list1 = ["hello", 12, 12.8]
    del list1[0]
    print(list1)  # [12, 12.8]

使用 `pop()` 弹出列表的最后一个元素。

list1 = ["hello", 12, 12.8]
    print(list1.pop())  # 12.8

**统计列表中某个元素出现的次数**

使用 `count()` 得到某个元素出现的次数。

list1 = ["hello", 12, 12.8, 12]
    print(list1.count(12))  # 2

## 六、对元组的操作 ##

元组和列表最大的不同是：元组一旦创建，里面的元素不可变更。一旦发生变更，就会创建一个新的元组。

其余操作和列表几乎一致。

## 七、对字典的操作 ##

**合并多个字典**

使用 `update` 完成对字典的合并或更新：相同的key进行更新，不同的key进行合并。

dict1 = { "k1":"v1", "k2":"v2"}
    dict2 = { "k1":"update_k1", "k3":"v3"}
    dict1.update(dict2)
    print(dict1)  # {'k1': 'update_k1', 'k2': 'v2', 'k3': 'v3'}

**通过key获得对应的value**

使用 字典名\[“key”\] 获得该字典中对应key的value值。

dict1 = { "k1":"v1", "k2":"v2"}
    print(dict1["k1"])  # v1

**增加一个新的键值对**

使用 字典名\[“key”\] = “value” 向该字典中增加一个新的键值对。（如果该key已经存在，则更新该key的值）

dict1 = { "k1":"v1", "k2":"v2"}
    dict1["k3"] = "v3"
    print(dict1)  # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

## 八、对集合的操作 ##

集合中的元素是不可重复的。

**创建空的集合：**

var1 = { }  # 一对大括号创建一个空的字典
    var2 = set()  # 固定格式创建空的集合
    print(type(var1))  # <class 'dict'>
    print(type(var2))  # <class 'set'>

**并集**

var1 = { "gao", 12, 3.16}
    var2 = { "new", "gao"}
    print(var1.union(var2))  # {3.16, 'new', 'gao', 12}
    # 会自动去掉重复的元素

**交集**

var1 = { "gao", 12, 3.16}
    var2 = { "new", "gao"}
    print(var1.intersection(var2))  # {'gao'}

**差集**

var1 = { "gao", 12, 3.16}
    var2 = { "new", "gao"}
    print(var1.difference(var2))  # {3.16, 12}

**是否是子集**

var1 = { "gao", 12, 3.16}
    var2 = { "gao"}
    print(var2.issubset(var1))  # True

## 九、基本运算符 ##

![image-20210922224951285][]

整数和浮点数做运算，结果是浮点数。

![image-20210922225257397][] ![image-20210922225330040][]

[image-20210920103240035]: /images/20220828/bafd2d40954f409f9e463cb3729892c0.png
[image-20210920154255846]: /images/20220828/9ac5a1c6bc124a93a1392d8f6efeb550.png
[image-20210922224951285]: /images/20220828/3f14a8adf7e94902a39e16daebde13a0.png
[image-20210922225257397]: https://typora-pic-1304435145.cos.ap-beijing.myqcloud.com/image-20210922225257397.png
[image-20210922225330040]: /images/20220828/746488f87b9147148c66c7b0b60ec940.png