Python数据类型

  • 数字类型（Numeric Types）：
    • 整数（int）：表示整数值，如1、-5、100等。
    • 浮点数（float）：表示带有小数点的数值，如3.14、-2.5等。
    • 复数（complex）：表示实部和虚部的复数，如2+3j、-1+2j等。
  • 序列类型（Sequence Types）：
    • 字符串（str）：表示字符组成的序列，如"Hello"、"Python"等。
    • 列表（list）：表示可变的有序序列，可以包含不同类型的元素，如[1, 2, "apple", True]等。
    • 元组（tuple）：表示不可变的有序序列，可以包含不同类型的元素，如(1, 2, "apple", True)等。
  • 映射类型（Mapping Type）：
    • 字典（dict）：表示键-值对的集合，键必须是唯一的，如{"name": "John", "age": 25, "city": "New York"}等。
  • 集合类型（Set Types）：
    • 集合（set）：表示唯一、无序的元素集合，不允许重复元素，如{1, 2, 3, 4}等。
    • 冻结集合（frozenset）：表示不可变的集合，一旦创建后不能进行修改。
  • 布尔类型（Boolean Type）：
  • 布尔值（bool）：表示真（True）或假（False）的值，用于逻辑运算。
  • 空类型（None Type）：
    • None：表示空值或缺失值。

python类型转换的方法

  1. 整数转换：

    • int(x)：将x转换为整数类型。例如，int(3.14)将返回3。
    • int(x, base)：将x作为base进制数转换为整数。例如，int('1010', 2)将返回10。

  2. 浮点数转换：

    • float(x)：将x转换为浮点数类型。例如，float(5)将返回5.0。

  3. 字符串转换：

    • str(x)：将x转换为字符串类型。例如，str(10)将返回'10'。
    • repr(x)：将x转换为字符串类型，并使用合法的Python表达式表示。例如，repr('Hello')将返回"'Hello'"。

  4. 列表、元组和集合转换：

    • list(x)：将x转换为列表类型。例如，list("Hello")将返回['H', 'e', 'l', 'l', 'o']。
    • tuple(x)：将x转换为元组类型。例如，tuple([1, 2, 3])将返回(1, 2, 3)。
    • set(x)：将x转换为集合类型。例如，set([1, 2, 3])将返回{1, 2, 3}。

  5. 字典转换：

    • dict(x)：将x转换为字典类型。x可以是包含键值对的可迭代对象，或者包含双值子序列的可迭代对象。例如，dict([(1, 'one'), (2, 'two')])将返回{1: 'one', 2: 'two'}。

  6. 布尔类型转换：

    • bool(x)：将x转换为布尔类型。根据x的值，返回True或False。例如，bool(0)将返回False。

  7. 其他类型转换：

    • chr(x)：将一个整数转换为对应的Unicode字符。例如，chr(65)将返回'A'。
    • ord(x)：将一个字符转换为对应的Unicode整数值。例如，ord('A')将返回65。

python变量命名规则

在Python中，变量命名需要遵循一些规则和约定。以下是Python变量命名的规则：

  1. 变量名由字母、数字和下划线组成。
  2. 变量名必须以字母或下划线开头，不能以数字开头。
  3. 变量名对大小写敏感。例如，myVariable和myvariable是不同的变量名。
  4. 变量名应具有描述性，能够清晰地表达变量的用途或含义。
  5. 避免使用Python的保留字（关键字）作为变量名，如if、while、for等。可以使用help('keywords')命令查看所有保留字列表。
  6. 一般情况下，使用小写字母来命名变量，如count、name等。
  7. 对于多个单词组成的变量名，可以使用下划线进行单词之间的分隔，如first_name、student_age等。这种命名风格被称为下划线命名法（snake_case）。
  8. 尽量避免使用单个字符作为变量名，除非它们具有明确的含义。

以下是一些良好的变量命名示例：

1
2
3
4
age = 25
name = "John Smith"
is_student = True
total_score = 95.5

需要注意的是，良好的变量命名可以增加代码的可读性和可维护性，使代码更易于理解和修改。选择有意义的变量名有助于提高代码的可理解性和可靠性。

Python的关键字

以下是Python 3中的关键字（保留字）列表：

1
2
3
4
5
6
7
False      class      finally    is         return
None       continue   for        lambda     try
True       def        from       nonlocal   while
and        del        global     not        with
as         elif       if         or         yield
assert     else       import     pass
break      except     in         raise

这些关键字具有特殊的含义和用途，用于构建Python程序的语法结构和控制流程。在变量命名时，应避免使用这些关键字作为变量名，以免产生冲突。

Python常量

在Python中，没有严格的常量概念，因为Python中的变量是可以重新赋值的。然而，惯例上，我们将不希望被修改的变量称为常量，并使用大写字母命名以表示其为常量。以下是Python中一些被视为常量的约定：

  1. 数字常量：

    • True：表示布尔值真。
    • False：表示布尔值假。
    • None：表示空值或缺失值。

  2. 数字常量：

    • 数字常量是指直接在代码中使用的数字，如1、3.14等。它们可以用作计算和赋值等操作。

  3. 字符串常量：

    • 字符串常量是指用引号括起来的文本，如”Hello”、’Python’等。它们表示不可变的字符串值。

  4. 特殊字符常量：

    • '\n'：表示换行符。
    • '\t'：表示制表符。
    • '\r'：表示回车符。

除了约定的常量之外，Python还提供了一些模块，如math和constants，用于访问一些常用的数学和物理常量。例如，math.pi表示圆周率π的近似值。

虽然这些约定和模块可以将某些变量标识为常量，但请记住，它们仍然是可以被修改的变量，因为Python本身并没有提供对常量的内置支持。

python运算符

Python 3中包含了多种运算符，用于执行各种计算和操作。以下是Python 3中常用的运算符：

  1. 算术运算符：
  • +：加法运算符，用于两个数相加。
  • -：减法运算符，用于从第一个数中减去第二个数。
  • *：乘法运算符，用于两个数相乘。
  • /：除法运算符，用于将第一个数除以第二个数。
  • //：整除运算符，返回两个数相除的整数部分。
  • %：取模运算符，返回两个数相除的余数。
  • **：幂运算符，返回第一个数的第二个数次幂。
  1. 比较运算符：
  • ==：相等运算符，用于判断两个值是否相等。
  • !=：不等运算符，用于判断两个值是否不相等。
  • >：大于运算符，用于判断第一个值是否大于第二个值。
  • <：小于运算符，用于判断第一个值是否小于第二个值。
  • >=：大于等于运算符，用于判断第一个值是否大于等于第二个值。
  • <=：小于等于运算符，用于判断第一个值是否小于等于第二个值。
  1. 逻辑运算符：
  • and：逻辑与运算符，用于判断多个条件是否同时为真。
  • or：逻辑或运算符，用于判断多个条件是否至少有一个为真。
  • not：逻辑非运算符，用于对条件进行取反操作。
  1. 赋值运算符：
  • =：赋值运算符，用于将右侧的值赋给左侧的变量。
  • +=：加法赋值运算符，将右侧的值与左侧的变量相加，并将结果赋给左侧的变量。
  • -=：减法赋值运算符，将右侧的值从左侧的变量中减去，并将结果赋给左侧的变量。
  • *=：乘法赋值运算符，将右侧的值与左侧的变量相乘，并将结果赋给左侧的变量。
  • /=：除法赋值运算符，将左侧的变量除以右侧的值，并将结果赋给左侧的变量。
  1. 位运算符：
  • &：按位与运算符，对两个数的每一位进行与操作。
  • |：按位或运算符，对两个数的每一位进行或操作。
  • ^：按位异或运算符，对两个数的每一位进行异或操作。
  • ~：按位取反运算符，对一个数的每一位进行取反操作。
  • <<：左移运算符，将一个数的所有位向左移动指定的位数。
  • >>：右移运算符，将一个数的所有位向右移动指定的位数。
  1. 成员运算符:

Python 3中有两个成员运算符，用于判断一个值是否属于某个集合。这两个成员运算符分别是：

  • in：用于判断某个值是否存在于给定的序列（如列表、元组、字符串、集合等）中。如果存在，返回True；否则返回False。
  • not in：用于判断某个值是否不存在于给定的序列中。如果不存在，返回True；否则返回False。

以下是成员运算符的使用示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 列表
numbers = [1, 2, 3, 4, 5]
print(3 in numbers)  # 输出: True
print(6 not in numbers)  # 输出: True

# 字符串
text = "Hello, Python"
print("Python" in text)  # 输出: True
print("world" not in text)  # 输出: True

# 元组
fruits = ("apple", "banana", "orange")
print("banana" in fruits)  # 输出: True
print("grape" not in fruits)  # 输出: True

# 集合
s = {1, 2, 3, 4}
print(2 in s)  # 输出: True
print(5 not in s)  # 输出: True

成员运算符能够方便地检查某个值是否存在于集合中，使得代码编写更加简洁和易读。

  1. 身份运算符:
  • is：用于判断两个对象是否是同一个对象，即它们是否具有相同的身份（内存地址）。如果是同一个对象，返回True；否则返回False。
  • is not：用于判断两个对象是否不是同一个对象，即它们是否具有不同的身份（内存地址）。如果不是同一个对象，返回True；否则返回False。
  • id()：内置函数id()用于获取对象的唯一标识（身份），即对象在内存中的地址。可以使用id(obj)来获取对象obj的唯一标识。

运算符优先级

  1. () 19
  2. x[i] 18
  3. x.attribute 17
  4. ** 指数运算符 16
  5. ~ 按位取反 15
  6. +正号 -负号 符号运算符 14
  7. * / % // 乘除 13
  8. + - 加减 12
  9. >> << 位移 11
  10. & 按位与 10
  11. ^ 按位异或 9
  12. | 按位或 8
  13. == != <= < > >= 比较运算符 7
  14. is is not 身份运算符 6
  15. in not in 成员运算符 5
  16. not 逻辑非 4
  17. and 逻辑与 3
  18. or 逻辑或 2
  19. exp1,exp2 逗号运算符 1

列表&元组

列表定义

list 列表定义使用中括号 [ ] ，里面元素可以是任意类型，也包括列表本身，也可以是字典、元组等。

1
2
3
4
list1 = ['Google', 'woodman', 1987, 2017]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = [2017, 'A', True, list1, list2]  # 列表中可以嵌套列表，字典，元组等

注意：列表里面数据可以是任意数据类型，它的长度也是可变的，这就是动态类型好处。

访问列表

list 列表（序列）中的每个元素都分配一个数字索引，从 0 开始，第一个索引是 0，第二个索引是 1，依此类推。

我们可以通过索引号访问列表的值，如：

1
2
3
4
5
6
l = ['Google', 'woodman', 1987, 2017]
print('l[0]=', l[0])
print('l[1]=', l[1])
print('l[3]=', l[3])
print('l[-1]=', l[-1])  # 可以倒序访问列表，-1列表倒数第一个
print('l[4]=', l[4])  # 此行会报错，抛出 IndexError 异常，列表下标越界

注意：访问list时索引号不能越界，不然会抛出 IndexError 异常

修改和新增列表的值

我们可以对列表的数据项进行修改。可以直接通过索引号修改列表的值，也可以通过 append() 方法对列表增加值。

1
2
3
4
5
6
7
8
9
10
l = ['Google', 'woodman', 1987, 2017]
print('原列表', l)

# 修改列表第二个值
l[1] = '中国人' 
print('修改后的列表', l)

# 在列表的末尾追加值
l.append('末尾追加元素') 
print('新增值后的列表', l)

拓展：

可以使用 insert ( index , vaule ) 方法在列表指定位置插入值，它接受两个参数，第一个参数为索引号，第二个参数是待添加的新元素。（ insert () 方法很少用到，知道有这个东西就可以，重点在 append ( ) 末尾追加）

示例：

1
2
3
# 在第二个位置插入，插入后 后面元素向后移一位
l.insert(1, '知乎')
print(l)

删除元素

删除元素的方法有del、 pop()、remove() , 最常用到的是pop()，其次remove()，最后才是del。

del 、 pop()、remove() 他们之间存在明显的区别，

del 通过指定具体值删除

del 是 Python 内置用于删除变量的引用（如果比较难理解，你可认为他是删除变量），list列表中的值其实都是一个一个的变量如list[0]、list[1]、list[2]都是他们的变量名。

我们要删除一个变量，直接 【del 变量名】，之后引用变量就会抛出异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a=1
del a    # 删除变量a，解除a对1的引用 
print(a) #  出现NameError 异常，没有a这个变量

l = ['Google', 'woodman', 1987, 2017]
print(l)

del l[0]  # 删除列表第一个元素
print(l)  # 输出 ['woodman', 1987, 2017]

del l[0:2]  # 删除列表第一到第二个元素
print(l)
del l  # 删除整个列表
print(l)  # 列表无法访问，抛出 NameError ，提示无l这个变量

pop()通过索引号删除

l.pop ( 索引号 ) 是 list 内置方法，通过列表索引号来删除list元素的方法；不指定索引号时删除最后一个元素。pop ( ) 一次只能删除一个元素。

1
2
3
4
5
6
7
8
9
10
l = ['Google', 'woodman', 1987, 2017]
l.pop()  # 删除最后一个元素
print(l)  # 输出 ['Google', 'woodman', 1987]
l.pop(0)  # 删除列表第一个元素
print(l)  # 输出 ['woodman', 1987]

l1 = [1]  # 定义一个新列表，只有一个值 
print(l1)  # 输出 [1]
l1.pop()  # 删除列表的值
print(l1)  # 输出的是一个空列表，l1 列表还存在

remove() 删除首个符合条件的元素

l.remove ( ) 列表内置的方法，他是根据给定值查找列表，找到符合条件的第一个值删除，它也只能一次删除一个。

1
2
3
4
5
6
7
8
9
l = ['Google', 'woodman', 1987, 2017, 1987, 'woodman']
print(l)
l.remove(1987)  # 删除 1987
print(l)  # 注意观察值的变化，只删除了前一个 1987

l.remove('woodman')  # 删除 ‘woodman’
print(l)  # 输出 ['Google', 2017, 1987, 'woodman']

l.remove(2)  # 删除不存在的值会抛出 ValueError 异常

列表切片

列表切片和字符串切片差不多，可以分为以下几类。

获取多个元素的值

list[初始位置:结束位置]。

如：list[0:N],取前N个元素也就是索引为0-(N-1)的元素，从0开始取到list的索引号N-1为止，不包含索引号为N的元素。

1
2
3
l = ['Google', 'woodman', 1987, 2017, 'a', 1, 2, 3]
print(l[0:2])  # 第1到第2个
print(l[2:15])  # 2到15个，注意如果结束位超过列表长度不会报错

通过步长截取

list[初始位置:结束位置:步长] ， 步长表示每多少个取一个。

如：list[0:N:M] 从0开每M个数取一个直到list的N-1元素为止。

1
2
3
4
5
l = ['Google', 'woodman', 1987, 2017, 'a', 1, 2, 3]
print(l[0:4:2])  # 每2个数去1个，从第1到第4个
# 输出 ['Google', 1987]
print(l[2::3])  # 从第3个取，每3个取一个，取到结尾
# 输出  [1987, 1]

花式用法

1
2
3
4
5
6
7
8
l = ['Google', 'woodman', 1987, 2017, 'a', 1, 2, 3]
print(l[:3])  # 从开始到list第3个元素
print(l[1:])  # 从第二个到list结束
print(l[:])  # 获得一个与l相同的list
print(l[-1])  # 取倒数第一个元素
print(l[::-1])  # list倒叙
print(l[-3:-1])  # 倒数第三个到第二个
print(l[-4:-1:2])  # 从倒数第4个每2个取一个，到代数第二个

列表常用运算

+与*列表的算术运算

链接两个列表使用 + , 重复复制多个列表使用 * 。

示例：链接列表和重复复制

1
2
3
4
5
l1 = [1, 2, 3] + ['a', 'b', 'c']  # 连接
print(l1)   # 结果 [1, 2, 3, 'a', 'b', 'c']

l2 = ['Hello!'] * 3  # 重复复制
print(l2)  # 结果 ['Hello!', 'Hello!', 'Hello!']

in 成员运算

in 判断一个元素是否在列表中，存在返回 True，否则返回 False。

not in 与 in 相反，判断一个元素不存在列表中。

示例：

1
2
3
4
5
l1 = [1, 2, 3, 'a', 'b', 'c'] 
print(2 in l1)  # True
print(12 in l1)  # False
print(2 not in l1)  # False
print(12 not in l1)  # True

list 列表常用函数

  • len(list) 返回列表的长度

  • max(list) 返回列表中元素最大值，必须是相同类型对比

  • min(list) 返回列表元素最小值，必须是相同类型对比

  • list(tuple) 将元组转换为列表

1
2
3
4
5
6
7
8
l = ['Google', 'woodman', 1987, 2017, 'a', 1, 2, 3]
print(len(l))  # 列表元素个数
l1 = ['aA', 'bss', 'Ad']
print(max(l1))  # 返回列表元素最大值,l1列表值必须是同类型
l2 = [6, 2, 3, 5, 1]
print(min(l1))  # 返回列表元素最小值,l1列表值必须是同类型
t = (1987, 2017, 'a', 1, 2, 3)
print(list(t))  # 将元组转换为列表

list列表常用方法

list.append(obj) #在列表末尾添加新的对象
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值
list.index(obj) #从列表中找出第一个匹配项的索引位置
list.insert(index, obj) #将对象插入列表index位置
list.pop(obj=list[-1]) #移除列表中的一个元素（默认最后一个），返回移除值
list.remove(obj) #移除列表中的第一个匹配到的值
list.reverse() #反向列表中元素
list.sort([func]) #对原列表进行排序
list.clear() #清空列表
list.copy() #复制列表

注意：Python 一切皆对象，变量是对象，函数式对象，方法是对象，类是对象，他的一切都是对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
l = ['Google', 'woodman', 1987, 2017, 'a', 1, 2, 3]
l1 = [7, 8, 9]

l.append('a')  # 在列表末尾添加新的对象
print(l)
print(l.count('a'))  # 统计某个元素在列表中出现的次数

l.extend(l1)  # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
print(l)

l.index(1987)  # 从列表中找出某个值第一个匹配项的索引位置
print(l)

l.insert(2, 'woodman')  # 将对象插入列表
print(l)

l.pop()  # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
print(l)

l.remove('a')  # 移除列表中某个值的第一个匹配项

l.reverse()  # 反向列表中元素
print(l)

l2 = l.copy()  # 复制列表
print(l2)

l.clear()  # 清空列表
print(l)

l3 = [3, 4, 2, 9, 4]
l3.sort()  # 对原列表进行排序
print(l3)