目录

1. 掌握 变量 的命名和使用
2. 掌握 数字、字符串、None
3. 掌握 元组 和 列表
4. 掌握 字典 和 集合
5. 掌握常用类型转换函数
6. 数据类型归纳
7. 赋值、引用
8. is关键字、id函数、==运算符、小整数池、字符串驻留机制

前言: Python 是区分大小写的,在写代码时请注意!

一、变量 的命名和使用

简单的说,变量是编程中最基本的存储单位,变量会暂时性的存储你放进去的东西。变量的名字也做标识符。 (在计算机的角度来看,变量是用来从内存找到某个东西的标记。)

1.1 变量的命名

如: a = 1,则是将 数字1 赋值给 变量 a ,那么在后续的代码中你就可以通过 变量 a 来拿到 数字1 了。

执行以上代码,Python 帮我们做了两件事情。

1. 在内存中创建了一个数字1。
2. 在内存中创建了一个变量 a,并将它指向了 数字1。

注意符号=,它不是数学意义上的等号,在程序里被称为赋值符号。

变量的命名规则

提示: python中所有的关键字,可以通过以下代码查看。

import keyword print(keyword.kwlist)

1.2 使用变量

name = 'Hugh' # 定义一个变量并赋值 print(name) # 输出该变量的值

二、数字 字符串 None

先认识第一个函数: type,它有一个用途是返回对象的类型。

>>> print(type(1)) # 将会返回 <class 'int'>,说明 1 是 int 类型。

接下来讲解下 Python常用标准数据类型当中的 int、float、bool、str等。

2.1 数字

Python可以处理任意大小的整数,在程序中的表示方法和数学上的写法是一样的。如: 1、10、-100、0.5 等等。

在 Python 中,数字可以分为(整数、浮点数、复数)。

2.1.1 整型(int)

如: 1、2、3、0、-1、-2、-3 等,与数学意义上的整数是一样的。

对于很大的数,如 10000000,很难数清0的个数,在 Python 中,允许数字中间以 _ 分隔,写成 10_000_000_000。

整型可以使用不同进制的表示方法,默认情况下是 10进制。

number = 24 # 默认是十进制。 bin_number = 0b11000 # 以二进制来表示。 oct_number = 0o30 # 以八进制来表示。 hex_number = 0x18 # 以十六进制来表示。

进制表示

* 二进制: 0b 或 0B
* 八进制: 0o 或 0O
* 十六进制: 0x 或 0X
2.1.2 浮点型(float)

Python 将带小数点的数字都称为浮点数。

浮点数可以用数学写法 1.23、3.14、-0.9 等。

对于很大或很小的浮点数,则可以使用科学技术法表示,如 1.23 * 10的9次方,在 Python 中,可以使用 1.23e9 来表示。 如: f = 1.23e9

2.1.3 复数

关于复数的使用场景比较少,可自行百度了解。

2.1.4 布尔类型(bool)

布尔类型总共只有两个值 True 和 False。 布尔类型中的 True 的值等价于 数字 1,False 的值等价于 数字 0。

print(True == 1) # == 用于比较值是否相等,此处返回 True print(False == 0) # 此处返回 True print(isinstance(True, int)) # isinstance 用于判断一个对象是否属于某个类型,此处返回 True,说明 True 属于整型。 print(issubclass(bool, int)) # issubclass 用于判断一个类型是否是另一个类型的子类,此处返回 True,说明布尔类型是整型的子类。
2.1.5 数字间的常用运算符

常用的运算符有: +、-、*、/、**、%、

1. +: 与数学意义上的加法一致。如,1 + 1 返回 2。
2. -: 与数学意义上的减法一致。如,1 - 1 返回 0。
3. *: 与数学意义上的乘法一致。如,2 * 4 返回 8。
4. /: 与数学意义上的除法一致,但在 Python 中整数间的除法会返回浮点数类型。 如,4 / 2 返回 2.0。

2.2 字符串

字符串 就是一系列字符。在Python中,用引号括起的都是字符串,其中的引号可以是单/双/三引号。

提示: 代码里的所有标点符号都采用英文的标点符号(除了字符串中的内容)

2.2.1 转义

在计算机当中,有些字符我们无法手动书写,如换行符,所以需要特定的方式去表示。

1. 转义字符: \
2. 换行: \n
3. 转义单引号: \'
4. 转义双引号: \"
5. 转义反斜杠: \\
2.2.2 格式化
1. %
2. format
3. f-string
# % >>> 'Hello, %s' % 'World' 'Hello, World' >>> 'Hello, My name is %s, %d years old.' % ('Hugh', 27) 'Hello, My name is Hugh, 27 years old.' # format >>> 'Hello, {}'.format('World') 'Hello, World' >>> 'Hello, My name is {}, {} years old.'.format('Hugh', 27) 'Hello, My name is Hugh, 27 years old.' >>> 'Hello, My name is {1}, {0} years old.'.format(27, 'Hugh') 'Hello, My name is Hugh, 27 years old.' >>> 'Hello, My name is {name}, {year} years old.'.format(year=27, name='Hugh') 'Hello, My name is Hugh, 27 years old.' # f-string >>> f'Hello, {"World"}' 'Hello, World' >>> name = 'Hugh' >>> f'Hello, {name}' 'Hello, Hugh' >>> f'{"q":20}' 'q ' >>> f'{"q":<20}' 'q ' >>> f'{"q":>20}' ' q' >>> f'{"q":^20}' ' q '
2.2.3 常用运算符
>>> 'Hello' + ' World' 'Hello World' >>> 'China!' * 8 'China!China!China!China!China!China!China!China!'

2.3 None

空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。

None 是一个单例对象,全局唯一。

三、列表 和 元组

3.1 列表

list 是一种有序的容器,可以随时添加和删除其中的元素。 列表使用 [] 表示。

# 定义列表 >>> lis = ['Qiu', 'QiuQiu'] >>> 'Qiu' in lis True >>> len(lis) # 获取列表长度 2 >>> lis[0] # 访问列表的第一项,索引从 0 开始 'Qiu' >>> lis[-1] # 访问列表的最后一项,索引为 -1 'QiuQiu' # lis[2] 索引越界会抛出 IndexError,记得最后一个元素的索引是len(列表) - 1 >>> lis.append('AAM') # 往列表追加元素到末尾,注意,无返回值 >>> lis ['Qiu', 'QiuQiu', 'AAM'] >>> lis.insert(1, 'Jia') # 把元素插入到指定的位置 ['Qiu', 'Jia', QiuQiu', 'AAM'] >>> lis.pop() # 删除列表末尾的元素 'AAM' >>> lis.pop(1) # 删除指定位置的元素 'Jia' >>> lis[1] = 'Hugh' # 把某个元素替换成别的元素 # 二维列表 >>> lis = [[0, 1], [1, 2]] >>> [1, 2] * 3 [1, 2, 1, 2, 1, 2] >>> [1, 2] + [3, 4] [1, 2, 3, 4] >>> list() []

3.2 元组

tuple 也是一种有序的容器,与列表类似,不同的是,元组是不可变的,意味着拥有类似列表的读取的操作,但是不具备增删改的操作。 元组使用 () 表示。

>>> t = (1, 2) >>> 1 in t True >>> t[0] 1 >>> t[-1] 2 >>> len(t) 2 >>> t = 1, 2 # 这也是定义一个元组 >>> t = 1, # 这也是定义一个元组 >>> t = (1, ) # 这也是定义一个元组 >>> t = 1 # 这是数字,不是元组了! >>> t = (1) # 这也是数字,不是元组了! >>> (1, 2) * 2 (1, 2, 1, 2) >>> (1, 2) + 3, 4 (1, 2, 3, 4)

四、字典和集合

4.1 字典

字典 使用键-值(key-value)存储,底层采用 hash 表存储,具有极快的查找速度。 使用 {} 表示。

>>> info = {'name': 'Qiu', 'age': 27} >>> info['name'] # 字典取值 'Qiu' >>> info['City'] = 'Sz' # 字典赋值 >>> info {'name': 'Qiu', 'age': 27, 'City': 'Sz'} >>> info['City'] = 'Sz' # 字典赋值 {'name': 'Qiu', 'age': 27, 'City': 'Gz'} >>> del info['age'] >>> info {'name': 'Qiu', 'City': 'Gz'} >>> info.pop('City') 'Gz' >>> info {'name': 'Qiu'} >>> dict() {} >>> type({}) <class 'dict'>

4.2 集合

集合是一个无序的容器,底层采用 hash 表存储,具有极快的查找速度。 特点:成员不能重复,所以经常用来去重(剔除重复元素)。 使用 {} 表示。

>>> brands = {'大众', '奔驰', '保时捷'} >>> '奔驰' in brands True >>> brands.add('比亚迪') >>> brands.update(['哈弗', '传祺']) >>> brands.update('五菱宏光', '小鹏') # 注意,传入的如果是可迭代对象会被拆开 >>> brands.remove('大众') # 删除元素,如果不存在,会报 KeyError >>> brands.discard('大众') # 删除元素,如果不存在,不会报 KeyError >>> brands.pop() # 随机删除集合中的一个元素 >>> {1, 2, 3} - {1, 2} # 对集合求差集,获取前一个集合有、后一个集合没有的东西。 {3} >>> {1, 2, 3}.difference({1, 2}) {3} >>> {1, 2, 3} | {3, 4, 5} # 对集合求并集,把两个集合里的东西合起来。 {1, 2, 3, 4, 5} >>> {1, 2, 3}.union({3, 4, 5}) {1, 2, 3, 4, 5} >>> {1, 2, 3} & {3, 4, 5} # 对两个集合求交集,也就是获取两个集合中同时存在的东西。 {3} >>> {1, 2, 3}.intersection({3, 4, 5}) {3} >>> {1, 2, 3} ^ {3, 4, 5} # 对称差集 返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素。 {1, 2, 4, 5} >>> {1, 2, 3}.symmetric_difference({3, 4, 5}) {1, 2, 4, 5} >>> len({1, 2, 3}) 3 >>> set() # 空集合,{} 已经被空字典占用 set()

五、常用类型转换函数

5.1 int

>>> int('123') 123 >>> int(12.3) 12 >>> int(12.9) 12 >>> int('abc') ValueError: invalid literal for int() with base 10: 'abc' >>> int('12.3') ValueError: invalid literal for int() with base 10: '12.3' >>> int('111') 111 >>> int('111', 2) # 2 ** 2 + 2 ** 1 + 1 7 >>> int('111', 8) # 8 ** 2 + 8 ** 1 + 1 73 >>> int(True) 1 >>> int(False) 0

5.2 float

>>> float(12) 12.0 >>> float('12.5') 12.5 >>> float(True) 1.0 >>> float(False) 0.0

5.3 bool

>>> bool(100) True >>> bool(0) False >>> bool(0.0) False >>> bool('') False >>> bool(None) False >>> bool(()) False >>> bool([]) False >>> bool({}) False >>> bool(set()) False

5.4 str

>>> str() '' >>> str(123) '123' >>> str(b'\xe4\xb8\xad\xe5\x9b\xbd', encoding='utf-8') '中国' >>> b'\xe4\xb8\xad\xe5\x9b\xbd'.decode('utf-8') '中国'

5.5 tuple

>>> tuple() () >>> tuple('abcd') ('a', 'b', 'c', 'd') >>> tuple(['a', 'b', 'c', 'd']) ('a', 'b', 'c', 'd') >>> tuple({'a', 'b', 'c', 'd'}) ('a', 'b', 'c', 'd') >>> tuple({'a': 1, 'b': 2, 'c': 3, 'd': 4}) ('a', 'b', 'c', 'd')

5.6 list

>>> list() [] >>> list('abcd') ['a', 'b', 'c', 'd'] >>> list(('a', 'b', 'c', 'd')) ['a', 'b', 'c', 'd'] >>> list({'a', 'b', 'c', 'd'}) ['a', 'b', 'c', 'd'] >>> list({'a': 1, 'b': 2, 'c': 3, 'd': 4}) ['a', 'b', 'c', 'd']

5.7 dict

>>> dict() {} >>> dict(name='Qiu', age=27) {'name': 'Qiu', 'age': 27} >>> dict([('name', 'Qiu'), ('age', 27)]) {'name': 'Qiu', 'age': 27}

5.8 set

>>> set() set() >>> set('abcd') {'a', 'b', 'c', 'd'} >>> set('abcdabcd') {'a', 'b', 'c', 'd'}

六、数据类型归纳

6.1 按照 可变 / 不可变 区分

1. 不可变
    1.1 str
    1.2 int、float、bool
    1.3 None
    1.4 tuple

2. 可变
    2.1 list
    2.2 dict
    2.3 set

6.2 容器类型

1. str
2. tuple
3. list
4. dict
5. set

通用操作: len、in

6.3 序列类型

有序的序列

1. str
2. list
3. tuple    

通用操作

1. 索引
2. 切片

七、赋值、引用

7.1 赋值、引用

>>> name = 'Hugh' >>> english_name = name

第一行代码,会在内存中创建一个变量 name 和一个字符串对象 'Hugh',并让 name 指向 'Hugh' 对象。 第二行代码,会在内存中创建一个变量 english_name,并让它指向 name 所指向的地方(也就是 'Hugh' 对象)。

>>> name = 'Qiu' >>> name 'Qiu' >>> english_name 'Hugh'

第一行代码,会在内存中创建一个字符串对象 'Qiu',并让变量 name 删除原来的指向('Hugh'),然后指向 'Qiu'。 所以,name 指向的 值是 'Qiu',而 english_name 仍然指向 'Hugh'。

八. is关键字、id函数、==运算符、小整数池、字符串驻留机制

8.1 is关键字 和 id函数、==运算符

id 函数用于获取对象的内存地址
is 运算符判断是否引用自同一对象
== 运算符判断两个运算对象的值是否相同

8.2 小整数池

Python驻留[-5, 256]的小整数

>>> a = 256 >>> b = 256 >>> a is b True >>> a = 257 >>> b = 257 >>> a is b False

8.3 字符串驻留机制

对于符合标识符规则的字符串(仅包含下划线,字母和数字),会启用字符串驻留机制。

>>> a = 'hello' >>> b = 'hello' >>> a is b True >>> a = 'hello ' >>> b = 'hello ' >>> a is b False