python 标准数据类型

1. 变量的概念

  • 在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。

  • 在 Python 中,变量不需要声明,但是 在使用前必须赋值,变量 赋值以后 该变量 才会被创建

  • 变量定义之后,后续就可以直接使用了。

2. 变量的赋值

  • 等号(=)用来给变量赋值。
    • = 左边是一个变量名。
    • = 右边是存储在变量中的值。

2.1 单个变量赋值

age = 18  # 整型变量
money = 14.5  # 浮点型变量
name = "xiaolizi"  # 字符串

2.2 多个变量赋值

# 下面示例会先创建一个整型对象,值为 1。然后从后向前赋值,三个变量被赋予相同的数值。
a = b = c = 1

2.3 为多个对象指定多个变量

# 注意两边都是用逗号分隔
a, b, c = 1, 2, 3

3. 变量的类型

3.1 在内存中创建一个变量,会包括

  1. 变量的名称

  2. 变量保存的数据

  3. 变量存储数据的类型

  4. 变量的地址(标识)

3.2 判断变量的类型

  • type() 函数

    num = 1
    str = '小李子'		
    
    print(type(num))
    print(type(str))
    
    
    out:
    	<class 'int'>
    	<class 'str'>
    
  • isinstance() 函数

    a = 2
    print(isinstance(a, int))
    
    out:
    	True
    
  • isinstance 和 type 的区别:

    • type() 不会认为子类是一种父类类型。

    • isinstance() 会认为子类是一种父类类型。

      # 所有的类都是 object 的子类
      print(type(int) == object)
      print(isinstance(int, object))
      
      out:
      	False
      	True
      

3.3 删除一个变量

a = 1
str = '小李子'

# 单个删除
del a
del str

# 批量删除
del a, str

3.4 Python3 中六个标准的数据类型

  • Number(数字)

  • String(字符串)

  • List(列表)

  • Tuple(元组)

  • Set(集合)

  • Dictionary(字典)

3.5 可变数据类型和不可变数据类型

Python3 的六个标准数据类型又分为两类:

  • 不可变数据类型(3 个):Number(数字)、String(字符串)、Tuple(元组)。
  • 可变数据数据类型(3 个):List(列表)、Dictionary(字典)、Set(集合)。

4. 数字类型(number)

4.1 int(整形)

Python3中,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。

可以使用十六进制(0x 开头)和八进制(0o 开头)来代表整数。

print(0xff)  # 两位16进制能表示的最大数
print(0o77)  # 两位八进制能表示的最大数

out:
	255
	63

4.2 float(浮点型)

浮 点 型 由 整 数 部 分 与 小 数 部 分 组 成 , 浮 点 型 也 可 以 使 用 科 学 计 数 法 表 示 , 1.2 e 3 = 1.2 ∗ 1 0 3 。 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示,1.2e3 = 1.2 * 10^{3} 。 使1.2e3=1.2103

# 科学计数法表示浮点数
print(1.2e3)

out:
	1200.0

4.3 bool(布尔型)

Python3 中,把 True 和 False 定义成关键字了,但它们的值还是 1 和 0,它们可以和数字相加。

4.4 complex(复数)

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

print(1 + 2j)
print(complex(1, 2))

out:
	(1+2j)
	(1+2j)

4.5 数据类型转换

* int(x):将x转换为一个整数。

*  float(x):将x转换到一个浮点数。

* complex(x):将x转换到一个复数,实数部分为 x,虚数部分为 0。 

* complex(x, y):将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。

5. 字符串(string)

5.1 可以使用单引号或双引号创建字符串

str01 = 'xiaolizi'
str02 = "huge"

5.2 字符串运算符

a = 'Hello'
b = 'Python'
操作符描述实例
+字符串连接a + b 输出:HelloPython
*重复输出字符串a*2 输出:HelloHello
[]通过索引获取字符串中字符a[1] 输出:e
[ : ]截取字符串中的一部分,遵循左闭右开原则,str[0:2] 是不包含第 3 个字符的。a[1:4] 输出:ell
in成员运算符 - 如果字符串中包含给定的字符返回 True‘H’ in a 输出:True
not in成员运算符 - 如果字符串中不包含给定的字符返回 True‘M’ not in a 输出:True
r/R原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。print( r’Hello\nWorld’ ) 输出:Hello\nWorld

5.3 格式化字符串

参考这篇文章:https://blog.csdn.net/lan123456_/article/details/108461098

5.4 Unicode 字符串

在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中,所有的字符串都是Unicode字符串。

5.5 python 的字符串内建函数

参考这篇文章:https://blog.csdn.net/lan123456_/article/details/108482703

6. 列表(list)

6.1 说明

python 中的列表类似 c 语言中的数组,但是列表的数据项不需要具有相同的类型。

创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。

与字符串的索引一样,列表索引从0开始。列表可以进行截取、组合等。

list = [1, 2, 'a', 'b', True, False]

6.2 访问列表中的元素

list = [1, 2, 'a', 'b', True, False]
print(list[0])  # 访问list的第一个元素
print([list[1:3])  # 访问list的第二和第三个元素


out:
	1
	[2, 'a']

6.3 更新列表中的元素

list = [1, 2, 'a', 'b', True, False]
list[2] = 3
print(list)  # [1, 2, 3, 'b', True, False]

6.4 删除列表中的元素

list = [1, 2, 'a', 'b', True, False]
del list[2]
print(list)  # [1, 2, 'b', True, False]

del list  # 删除列表

6.5 列表中的 +, *, in, not in

list01 = [1, 2]
list02 = [3, 4]

print(list01 + list02)  # 组合 list01 和 list02
print(list01 * 2)  # 重复 list01 两次
print(1 in list01)  # 判断某个元素是否在列表中
print(1 not in list02)  # 判断某个元素是否不在列表中

out:
	[1, 2, 3, 4]
	[1, 2, 1, 2]
	True
	False

6.6 列表截取

使用格式:list[start : end : stepLen]

参数:

  • start:可选参数,开始的索引位置,闭区间

  • end:可选参数,结束的索引位置,开区间

  • stepLen:可选参数,步长,如果为负数,则反向截取

list = [1, 2, 3, 4, 5, 6, 7, 8]

# 一个参数
print(list[0])  # 根据下标输出列表中的元素,下标从零开始
print(list[-1])  # -1 表示列表中最后一个元素,以此类推 -2, -3

# 两个参数
print(list[0:])  # 从第一个元素开始,截取到最后一个元素
print(list[:-1])  # 从第一个元素开始,截取到倒数第二个,因为第二个参数是开区间
print(list[:])  # 截取所有元素

# 三个参数
print(list[::2])  # 第三参数为正数,表示从前往后截取;步长为2,表示每隔一个元素截取一次;省略了第一和第二个参数,所以在整个列表范围内截取
print(list[::-1])  # 第三参数为负数,表示从后往前截取;步长是 1,表示每个元素都要截取;省略了第一和第二个参数,所以在整个列表范围内截取


out:
	1
	8
	[1, 2, 3, 4, 5, 6, 7, 8]
	[1, 2, 3, 4, 5, 6, 7]
	[1, 2, 3, 4, 5, 6, 7, 8]
	[1, 3, 5, 7]
	[8, 7, 6, 5, 4, 3, 2, 1]		

6.7 列表中嵌套其他数据类型的数据

列表中可以嵌套列表,元组,字典等等。

# 列表中嵌套列表,相当于二维数组
list = [[1, 2], [3, 4]]

# 列表中嵌套元组
list = [(1, 2), (3, 4)]

# 列表中嵌套字典
list = [{'a': 1}, {'b': 2}]

6.8 列表推导式

list = [x for x in 'abcdefg' if x not in 'cde']  # ['a', 'b', 'f', 'g']

6.9 列表常用函数和方法

参考这篇文章:https://blog.csdn.net/lan123456_/article/details/108792614

7. 元组(tuple)

7.1 说明

Python 的元组与列表类似,不同之处在于元组的元素不能修改。

元组使用小括号,列表使用方括号。

元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

# 创建一个空元祖
tup = ()
print(type(tup))  # <class 'tuple'>,type()函数返回变量的数据类型
# 或者
tup = tuple()
print(type(tup))  # <class 'tuple'>,type()函数返回变量的数据类型

# 用小括号创建一个元组
tup = (0, 'a', [1, 2])
# 也可以不用括号
tup = 1, 2, 3
  • 注意:

    元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用

tup01 = ('a')
print(type(tup01))  # <class 'str>

tup02 = ('a',)
print(type(tup02))  # <class 'tuple'>

7.2 元组的取值,截取,方法等操作都与列表一样

7.3 元组中的元素不能修改

不能修改或删除元组中的元素,但是可以将元组整个删除,或者重新赋值。

当元素是可变对象时,对象内部属性是可以修改的。

tup = (1, 2, 3)
tup = (4, 5, 1)  # 可以重新对元组变量赋值,改变指向
del tup  # 也可以直接删除元组变量

# 当元素是可变对象时,对象内部属性是可以修改的
tup = (1 , 2, [3, 4])
tup[2][0] = 5
tup[2][1] = 6
print(tup)  # (1 , 2, [5, 6]),表面上元组改变了,实际上改变的是元组中列表中的值,列表指向的内存地址并没有变,所以元组也没有改变

8. 字典(dict)

8.1 说明

字典是另一种可变容器模型,且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号(:)分割,每个键值对之间用逗号(,)分割,整个字典包括在花括号 {} 中。

  • 注意:
    • 键必须是唯一的,但值则不必。如果键不唯一,创建时,后面的会覆盖面的。
    • 值可以取任何数据类型,但键必须是不可变数据类型,如字符串,数字,元组。
    • Python 3.6 改写了 dict 的内部算法,因此 3.6 的 dict 是有序的,在此版本之前皆是无序

8.2 创建一个字典

# 创建一个空字典
dict01 = dict()

# 创建一个字典
dict02 = {'one': 1, 2: 'two', (1, 2): 3}

8.3 获取字典中的数据

dict = {'a': 1, 'b': 2, 'c': 3}

dict['a']  # 1
dict['d']  # KeyError: 'd',没有这个key值就会报错

8.4 修改字典中的数据

dict = {'a': 1, 'b': 2, 'c': 3}

# 修改数据
dict['a'] = 0  # {'a': 0, 'b': 2, 'c': 3}

# 增加数据
dict['d'] = 4  # {'a': 0, 'b': 2, 'c': 3, 'd': 4}

8.5 删除字典中的数据

dict = {'a': 1, 'b': 2, 'c': 3}

del dict['a']  # {'b': 2, 'c': 3}
del dict  # 删除字典

8.6 字典常用函数和方法

参考这篇文章:https://blog.csdn.net/lan123456_/article/details/108831130

9. 集合

9.1 说明

集合(set)是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合。

  • 注意:

    创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

set01 = {1, 2, 3}
# 或者
set02 = set([1, 2, 3])  # set() 函数只接收一个参数,初始化时可以传入一个列表或元组

9.2 集合运算

a = {'a', 'c', 'd', 'b', 'r'}
b = {'a', 'c', 'z', 'l', 'm'}

# 差集,集合a中包含而集合b中不包含的元素
# 1. 使用 - 运算符
print(a - b)
# 2. 或者 s1.difference(s2) 函数
print(a.difference(b))

# 并集,集合a或b中包含的所有元素
# 1. 使用 | 运算符
print(a | b)
# 2. 或者 s1.union(s2[, s3, s4]) 函数
print(a.union(b))  # 可以有多个参数

# 交集,集合a和b中都包含了的元素
# 1. 使用 & 运算符
print(a & b)
# 2. 或者 s1.intersection(s2[, s3, s4]) 函数
print(a.intersection(b))  # 可以有多个参数

# 对称差集,不同时包含于a和b的元素
# 1. 使用 ^ 运算符
print(a ^ b)
# 2. 或者 s1.symmetric_difference(s2) 函数
print(a.symmetric_difference(b))

out:
	{'d', 'r', 'b'}
	{'d', 'r', 'b'}
	{'d', 'm', 'a', 'z', 'l', 'c', 'b', 'r'}
	{'d', 'm', 'a', 'z', 'l', 'c', 'b', 'r'}
	{'a', 'c'}
	{'a', 'c'}
	{'d', 'r', 'm', 'l', 'z', 'b'}
	{'d', 'r', 'm', 'l', 'z', 'b'}

9.3 集合添加元素

  1. s.add(x)

    将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。

    只能添加不可变数据类型的数据,比如:字符串、元组、数字。

    只有一个参数。

    s = set([1, 2, 3])
    
    s.add(1)  # {1, 2, 3},不做任何操作
    s.add((4, 5))  # {(4, 5), 1, 2, 3}
    s.add([6, 7])  # 报错,TypeError: unhashable type: 'list'
    
  2. s.update(x)

    向集合中添加元素,且参数可以是列表,元组,字典等。

    参数可以有多个,用逗号分开。

    s = set([1, 2, 3])
    
    s.update(1)  # 报错,TypeError: 'int' object is not iterable
    s.update('ab')  # {1, 2, 3, 'a', 'b'},将字符串中每个字符作为一个元素更新到集合中
    s.update([4, 5], [6, 7])  # {1, 2, 3, 4, 5, 6, 7}
    

9.4 集合删除元素

  1. s.remove(x)

    将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。

    s = set([1, 2, 3])
    
    s.remove(1)  # {2, 3}
    s.remove(4)  # 报错,KeyError: 4
    
  2. s.discard(x)

    将元素 x 从集合 s 中移除,如果元素不存在,不会发生错误。

    s = set([1, 2, 3])
    
    s.discard(1)  # {2, 3}
    s.discard(4)  # {1, 2, 3},不会报错
    
  3. s.pop()

    随机删除集合中的一个元素,pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。

    s = {1, 2, 3}
    
    s.pop()  # {2, 3}
    

9.5 清空集合

  • s.clear()

    s = {1, 2, 3}
    s.clear()  # set()
    

9.6 其他常用函数

  • len(s)

    返回集合中元素的个数。

    s = {1, 2, 3}
    len(s)  # 3
    
  • x in / not in s

    判断元素 x 是否在集合 s 中。

    s = {1, 2, 3}
    
    print(1 in s)  # True
    print(4 not in s)  # True
    
  • s.copy()

    浅拷贝一个集合

    s = set([1, 2, 3])
    
    sc = s.copy()  # {1, 2, 3}
    
  • s1.difference_update(s2)

    用于移除两个集合中都存在的元素。

    difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合,而 difference_update() 方法是直接在原来的集合中移除元素,没有返回值。

    a = {'a', 'c', 'd', 'b', 'r'}
    b = {'a', 'c', 'z', 'l', 'm'}
    
    a.difference_update(b)
    print(a)  # {'b', 'r', 'd'}
    
  • s1.set.intersection_update(s2[, s3, s4])

    用于获取两个或更多集合中都重叠的元素,即计算交集。

    intersection_update() 方法不同于 intersection() 方法,因为 intersection() 方法是返回一个新的集合,而 intersection_update() 方法是在原始的集合上移除不重叠的元素。

    a = {'a', 'c', 'd', 'b', 'r'}
    b = {'a', 'c', 'z', 'l', 'm'}
    
    a.intersection_update(b)
    print(a)  # {'a', 'c'}
    
  • s1.symmetric_difference_update(s2)

    移除 s1 集合中与 s2 集合相同的元素,并将 s2 集合中不同的元素插入到 s1 集合中。

    a = {'a', 'c', 'd', 'b', 'r'}
    b = {'a', 'c', 'z', 'l', 'm'}
    
    a.symmetric_difference_update(b)
    print(a)  # {'l', 'd', 'r', 'b', 'm', 'z'}
    
  • s1.isdisjoint(s2)

    判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。

    a = {'a', 'c', 'd', 'b', 'r'}
    b = {'a', 'c', 'z', 'l', 'm'}
    
    print(a.isdisjoint(b))  # False
    
  • s1.issubset(s2)

    判断集合 s1 的所有元素是否都包含在 s2 集合中,如果是则返回 True,否则返回 False。

    a = {'a', 'c'}
    b = {'a', 'c', 'z', 'l', 'm'}
    
    print(a.issubset(b))  # True
    
  • s1.issuperset(s2)

    判断集合 s2 的所有元素是否都包含在集合 s1 中,如果是则返回 True,否则返回 False。

    a = {'a', 'c'}
    b = {'a', 'c', 'z', 'l', 'm'}
    
    print(a.issubset(b))  # False
    
©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页