Python基础学习之数据类型操作

水深无声 2022-12-09 02:59 300阅读 0赞

# Python基础学习之数据类型 #

### 文章目录 ###

*  Python基础学习之数据类型
 *   *  1. 数字类型
     *   *   *  1.1 整型(Int)
             *  1.2 浮点型(float)
             *  1.3 复数 (complex) （除特殊行业，基本不使用）
             *  1.4 数据进制转换（二进制，八进制，十进制，十六进制）
     *  2. 元组类型
     *   *   *  2.1 元组tuple与列表list的异同点
             *  2.2 元组的陷阱
     *  3. 布尔类型
     *   *   *  3.1 布尔类型介绍
             *  3.2 布尔运算
     *  4. 集合类型
     *   *   *  4.1 集合的创建
             *  4.2 集合的增、删、改、查

Python中的数据类型有：数字类型，元组类型，布尔类型，集合类型，列表类型，字典类型，字符串类型；其中，列表类型，字典类型，字符串类型 比较复杂，分别用三篇博客来介绍说明；参考如下：  
列表类型：[Python基础学习之列表操作][Python]  
字典类型：[Python基础学习之字典操作][Python 1]  
字符串类型：[Python基础学习之字符串操作][Python 2]

## 1. 数字类型 ##

Python 支持三种不同的数值类型：整型(int)，浮点型(float)，复数(complex)；分别介绍如下：

#### 1.1 整型(Int) ####

整型是最常见的数据类型，是正或负整数，不带小数点。Python3 整型是没有限制大小的，默认为Long int。

#### 1.2 浮点型(float) ####

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）;

#### 1.3 复数 (complex) （除特殊行业，基本不使用） ####

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。仅做了解；

#### 1.4 数据进制转换（二进制，八进制，十进制，十六进制） ####

1.4.1 常用的进制为：二进制bin()，八进制oct(dec)，十进制(默认)，十六进制hex(dec)；  
1.4.2 直接定义不同进制数字：

# 二进制数字
    a = 0b10101   # 二进制数字
    print(a)    # 会输出其十进制的值:21
    print(bin(a))  # 想要输出二进制，就是用bin()；输出：0b10101
    
    # 八进制数字
    b = 0o7654321   # 八进制数字
    print(b)    # 会输出其十进制的值:2054353
    print(oct(a))  # 想要输出八进制，就是用oct()；输出：0o7654321
    
    # 十六进制数字
    c = 0xABC123   # 十六进制数字
    print(c)    # 会输出其十进制的值:11256099
    print(hex(a))  # 想要输出八进制，就是用hex()；输出：0xABC123

1.4.3 进制转换

d = 12   # 十进制
    print(bin(d))  # 10 ->2 输出二进制：0b1100
    print(oct(d))  # 10 ->8 输出八进制：0o14
    print(hex(d))  # 10 ->16 输出十六进制：0xc

## 2. 元组类型 ##

#### 2.1 元组tuple与列表list的异同点 ####

元组tuple与列表list非常相似，不同点是：  
a. 元组使用() 来标识； 列表使用\[\] 来标识；  
b. 元组不可变，tuple一旦初始化就不能修改；列表可变；  
举例：

names = ('Zhang Kai','JJ')

定义完成后，names就不能再修改，没有append()，insert() 等方法；不能修改的元组可以保证代码的安全性，所以在可能的情况下，使用元组可以增加程序的安全性；

#### 2.2 元组的陷阱 ####

2.2.1 单独一个数字的元组，需要在数字后加一个 ,

a = (1)   # 因为()是运算符，所以这里的a，只是一个整数
    print(a)    # 输出：1 ，是一个int类型
    b = (1,)   # 为防止这种情况，需要再
    print(b)   # 输出：(1,)，是一个元组类型

2.2.2 元组中的列表

t = ('a', 'b', ['X', 'Y'])
    t[2][0] = 'a'
    t[2][1] = 'b'
    print(t)    # 输出：('a', 'b', ['a', 'b'])

这里元组 t 中的列表值会变，并不是因为元组的值变了；元素中存储的是列表的指针，元素中的指针不会变，但是列表是可变的；这一点与列表的浅复制是完全一样的原理，可以参考：[Python基础学习之列表操作][Python] 中 4.0 列表的复制；

## 3. 布尔类型 ##

#### 3.1 布尔类型介绍 ####

布尔类型只有两种值： True & False；**需要特别注意的是：这里的True & False 的首字符必须要大写；** Python把0、空字符串’‘和None看成 False，其他数值和非空字符串全部当作 True；所以，我们只需记住0，’’，None 三个对应False，其余所有的值全部为True；  
由于以上特性，所以我们经常可以使用布尔类型与其他类型做与或非(and, or, not )的运算，可以使用bool() 将其他类型转化为布尔类型，例如：

a=''
    b= 'False'
    c= False
    print(bool(a))    # 输出：False
    print(bool(b))    # 输出：True
    print(not a)      # 输出：True
    print(not not b)  # 可以使用双重否定来代替bool()

#### 3.2 布尔运算 ####

布尔类型常用运算为：与或非，即：and, or, not ;举例如下：  
3.2.1 与运算 and , 有假则为假，全真才为假真；

print(True and True)    # 输出：True
    print(True and False)     # 输出：False
    print(False and True)     # 输出：False
    print(False and False)     # 输出：False

3.2.2 与运算 and , 有假则为假，全真才为假真；

print(True or True)     # 输出：True
    print(True or False)     # 输出：True
    print(False or True)     # 输出：True
    print(False or False)     # 输出：False

3.2.3 非运算 not, 取反；

print(not True)     # 输出：False
    print(not False)     # 输出：True

## 4. 集合类型 ##

#### 4.1 集合的创建 ####

集合（set）是一个无序且元素不能重复的序列；  
创建集合有两种方式：1. \{\} 2.set()， 需要注意的是：创建空集合时必须用set()，不能使用\{\}，因为\{\}默认为一个空字典；举例如下：

# 集合的创建
    names = { 'James','Jay','JJ'}
    print(names)    # 输出：{'Jay', 'James', 'JJ'}
    
    names = set(('James','Jay','JJ'))   # 用元组传入
    print(names)    # 输出：{'Jay', 'James', 'JJ'}
    
    names = set(['James','Jay','JJ'])   # 用列表传入
    print(names)    # 输出：{'Jay', 'James', 'JJ'}

注意：set() 中只能传入一个参数，所以，我们需要传入一个元组或者一个列表来创建集合；当我们传入一个字符串时，字符串会被拆分为字母，且重复的元素会被删除；举例如下：

names = set('abc abc abc abc')
    print(names)   # 输出：{'b', 'a', ' ', 'c'}

#### 4.2 集合的增、删、改、查 ####

4.2.1 增加元素，一般有两种方法：add() 和 update()，举例如下：

# 元素增加
    # add()
    names = set(('James','Jay','JJ'))
    names.add('Mario')     # 只可以单个添加，不可以使用元组，列表等作为传入参数
    print(names)      # 输出：{'Mario', 'JJ', 'James', 'Jay'}
    
    
    # update()
    names = set(('James','Jay','JJ'))
    names.update('Mario')     # 可以使用元组，列表等作为传入参数，当直接传入字符串时，字符串会被拆分；
    print(names)      # 输出：{'o', 'r', 'Jay', 'i', 'James', 'JJ', 'M', 'a'}
    
    names = set(('James','Jay','JJ'))
    names.update(['Mario'])     # 所以传入单值时，也需要使用()或者[]，才可以；
    print(names)      # 输出：{'Mario', 'JJ', 'James', 'Jay'}
    
    names.update(['Mario','Karry'])   # 可以一次添加多个元素，当添加的元素重复时，则去除重复；
    print(names)      # 输出：{'Jay', 'James', 'JJ', 'Karry', 'Mario'}
    
    # update() 的传入参数可以有多个，举例：
    names  = set(('James','Jay','JJ'))
    names.update(['Mario'],['Karry'])   # 可以一次添加多个元素，中间用，隔开；
    print(names)      # 输出： {'Mario', 'James', 'Karry', 'JJ', 'Jay'}

4.2.2 元素删除  
常用的删除集合元素的方法有：remove(), discard(), pop(), clear()，del， 举例如下：

# 元素删除
    # remove()
    names  = set(('Mario', 'James', 'Karry', 'JJ', 'Jay'))
    names.remove('Mario')
    print(names)    # 输出：{'James', 'Karry', 'JJ', 'Jay'}
    
    # names.remove('lucy') # 如果元素不存在，则报错：KeyError: 'lucy'
    
    # discard()
    names.discard('James')
    print(names)   # 输出：{'JJ', 'Jay', 'Karry'}
    names.discard('lucy')   # 如果需要删除的元素不存在，不报错；这点是与remove() 的区别；
    print(names)  # 输出：{'JJ', 'Jay', 'Karry'}
    
    
    # pop()
    a = names.pop()    # 随机删除一个元素，所以每次删除的都不一定；pop() 返回被删除的值
    print(names)   # 输出：{'Jay', 'JJ'}
    print(a)       # 输出：Karry
    
    # clear()
    names.clear()    # 将names 清空
    print(names)     # 输出：set()
    
    # del
    del names      # 删除names变量

4.2.3 元素的修改，集合不支持元素的修改；  
4.2.4 集合的查询 len(), in  
可以查询集合的元素个数(使用 len)，可以查询一个元素是否在集合中（使用 in）；举例如下：

names  = set(('Mario', 'James', 'Karry', 'JJ', 'Jay'))
    a=len(names)
    print(a)    # 输出：5
    
    print('Mario' in names)    # 输出：True 存在输出True, 不存在输出False

4.3 集合的运算

a = set('abcdefg')
    b = set('abcj')
    
    print(a - b)    # 差集，输出：{'d', 'f', 'e', 'g'}
    print(a | b)    # 并集，输出：{'d', 'j', 'g', 'f', 'e', 'a', 'c', 'b'}
    print(a & b)    # 交集，输出：{'b', 'c', 'a'}
    print(a ^ b)    # 并集-交集，输出：{'j', 'd', 'g', 'f', 'e'}

4.3.1 差集，即：a - b；  
4.3.2 并集，即： a | b；  
4.3.3 交集，即： a & b；  
4.3.3 并集-交集，即：a ^ b；

[Python]: https://blog.csdn.net/weixin_47139649/article/details/108662144
[Python 1]: https://blog.csdn.net/weixin_47139649/article/details/108669075
[Python 2]: https://blog.csdn.net/weixin_47139649/article/details/108646750