Python——基础篇

布鲁斯的快乐小屋

已于 2025-03-04 23:16:02 修改

阅读量1k

点赞数 18

CC 4.0 BY-SA版权

文章标签： python 开发语言

于 2025-01-22 23:42:13 首次发布

本文链接：https://blog.csdn.net/weixin_74090771/article/details/145312596

1. python注释

单行注释：注释内容前加上一个 # 即可

多行注释：注释内容写在一对三引号之间即可，""" """或''' '''

"""
这是多行注释
这是多行注释
"""
print("hello python") # 这是单行注释

2. `python`标识符的命名规则和规范

在 Python 中，标识符是指用来标识变量、函数、类、模块以及其他对象的名称。

2.1 标识符的命名规则

标识符由字母、数字和下划线组成【中文命名也支持】，例如my_variable、_private_var、class1等。标识符不能以数字开头，且最好不要使用中文命名，防止出现未知错误。
python中标识符严格区大小写，且标识符中不能含有除了下划线的特殊字符。
不能使用关键字作为标识符，否则编译器会报错，但是可以使用内置函数名作为标识符，但要尽量避免。

2.2 标识符的命名规范

为了提高代码的可读性，标识符的命名应该尽可能地反映其用途或所代表的事物。例如，用total_count表示总数，calculate_average表示计算平均值的函数等。

变量和函数：通常采用小写字母加下划线的方式，如local_variable、calculate_sum。
类：一般使用大写字母开头的驼峰命名法，如MyClass、AnotherClass。
模块：模块名一般用小写字母，如果有多个单词，用下划线连接，如my_module.py。
常量：常量通常用全大写字母表示，单词之间用下划线分隔，如MAX_VALUE、PI。

3. 变量和常量

在python中，字面值是指在程序中直接表示数据值的符号，如下：

# 数字字面值
print(10)  # 十进制整数
print(0b1010)  # 二进制整数
print(0o12)  # 八进制整数
print(0xA)  # 十六进制整数
print(3.14)  # 浮点数
print(1.23e-4)  # 科学计数法表示的浮点数
print(1 + 2j)  # 复数

# 字符串字面值
print('Hello, World!')  # 单引号字符串
print("Hello, World!")  # 双引号字符串
print('''This is a
multiline
string.''')  # 三引号多行字符串
print(r'C:\path\to\file')  # 原始字符串

# 布尔字面值
print(True)
print(False)

# 空字面值
print(None)

# 集合字面值
print([1, 2, 3])  # 列表
print((1, 2, 3))  # 元组
print({1, 2, 3})  # 集合
print({'name': 'Alice', 'age': 25})  # 字典

3.1 变量

变量是存储数据的容器，可以存储不同类型的数据，如整数、浮点数、字符串、列表、字典等。在 Python 中，变量的定义不需要提前声明数据类型，直接赋值即可创建变量。在 Python 中，变量的定义不需要提前声明数据类型，直接赋值即可创建变量。例如：

x = 10
name = "Alice"
my_list = [1, 2, 3]

变量都必须先定义后使用，如果使用未定义的变量程序则会报错，如下：

print(number)

# 报错信息
Traceback (most recent call last):
  File "E:\PYTHON_CODE\test.py", line 1, in <module>
    print(number)
NameError: name 'number' is not defined

变量最大的特性就是其【可变性】，变量的值可以在程序执行过程中被修改，例如：

x = 5
print(x)  # 输出 5
x = 10
print(x)  # 输出 10

变量的【作用域】决定了它在程序哪部分可以被访问，变量分为局部变量和全局变量，其中局部变量仅能在函数内部使用，而全局变量则可以在整个程序中使用，如下：

global_var = 100  # 全局变量

def my_function():
    local_var = 200  # 局部变量
    print(global_var)  # 可以访问全局变量
    print(local_var)  # 可以访问局部变量

my_function()
print(global_var)  # 可以访问全局变量
print(local_var)  # 会引发 NameError，因为局部变量仅在函数内部可访问

3.2 常量

Python 中没有内置的常量类型，通常使用大写字母命名的变量来表示常量，以表示其值不应该被修改。因此，常量不等于字面值。

PI = 3.14159
MAX_VALUE = 100

4. 输入和输出

4.1 输入函数`input`

input() 函数是python的内置函数，用于从用户那里接收输入，它将用户输入的内容作为字符串返回，如果需要其他类型的数据，需要进行类型转换。其一般格式为变量名 = input(<提示字符串>)，如下：

user_input = input("Please enter your name: ")
print(f"Hello, {user_input}!")

num = int(input("Please enter a number: "))  # 转换为整数
float_num = float(input("Please enter a float: "))  # 转换为浮点数

4.2 输出函数`print`

print() 是 Python 中最常用的输出函数，它可以将数据输出到标准输出，通常是控制台。print()函数没有返回值，可以输出任何变量，包括但不限于数值型、布尔型、列表型、字典型等。

4.2.1 函数语法

print(*objects, sep=' ', end='\n', file=file)

objects：对应复数，表示可以一次输出一个或多个对象，用,进行分隔。
sep：用于间隔多个对象，默认是一个空格。
end：用于设定以什么为结尾，默认是换行符\n。

file：指定输出的目标位置，默认值为sys.stdout，表示输出到控制台。

name = "Bruce"
number = 12223040234
print(name, number, sep=" ", end="\n")	# Bruce 12223040234

# file参数的使用

# 将内容写入文件
with open("output.txt", "w") as f:
    print("Hello, World!", file=f)
    
    
# 自定义日志信息输出
log_file = open("log.txt", "w")
print("INFO: This is a log message.", file=log_file)
log_file.close()

4.2.2 格式化输出

【使用%操作符】：类似C语言。常见的占位符有%s 格式化字符串、%d 格式化整数、%o 格式化无符号八进制数、%x 格式化无符号十六进制数、%f 格式化浮点数、%p 用十六进制数格式化变量的地址。
```
name = "Bruce"
number = 12223040234
print("%s的学号是%d" % (name, number)) 
```
```
name = "Bruce"
number = 12223040234
print("%(name)s 的学号是 %(number)d" % {"number": number, "name": name})
```
注意点：如果字符串中使用了占位符，但是字符串中需要使用 % ，则可以在%前面加上一个%，告诉解释器当前%不是一个占位符，就单纯是一个百分号。
```
name = "Bruce"
print("%s 持股 90%%") # Bruce持股90%
```

【使用str.format()函数】

print("My name is {} and I am {} years old.".format(name, age))
# 使用位置参数
print("My name is {0} and I am {1} years old.".format(name, age))
# 关键字参数
print("My name is {name} and I am {age} years old.".format(name=name, age=age))

使用【f-string】：使用f-string格式化字符串时，{}中可以使用表达式。

name = "Bruce"
number = 12223040234
strs = f"{name}的学号是{number}"
print(strs)

number = 100
print(f"number加100的结果为{number + 100}")  # number加100的结果为200
print(f"number加100的结果为{number + 100 = }") # number加100的结果为number + 100 = 200

strs = "bruce"
print(f"{strs.upper()}")    # BRUCE

# 使用f-string将十进制数转换为二进制、八进制、十六进制
number = 22
print(f"{number: #b}")  # 0b10110
print(f"{number: #o}")  # 0o26
print(f"{number: #x}")  # 0x16

5. 数据类型

基本数据类型包括数值型、字符串、布尔型，容器数据类型包括列表、元组、集合、字典，特殊数据类型包括空值、字节类型。

5.1 数值类型

5.1.1 整型`int`

在python3中，取消了长整型long，int可以表示任意大小的整数。

x = 10
y = -5
large_number = 123456789012345678901234567890

整数的进制表示：
- 二进制数：以0b开头。
- 八进制数：以0o开头。
- 十六进制数：以0x开头。
整数常量池：在python中，对于在[-5, 256]范围内的整数，在程序启动时就会加载到内存中，并在整个程序运行期间重复使用；对于超出这个范围的整数，会根据需要动态地添加到整数常量池中，后续再使用到该整数时就不会重复创建。整数常量池地目的就是优化性能和内存使用。
```
# a和c的内存地址相同，它们指向同一个对象
a = 10  # 140720610815168
b = 13  # 140720610815264 
c = 10  # 140720610815168
print(id(a), id(b), id(c))
```
```
a = 10000000000000  # 2254880192400
b = 10000000000000  # 2254880192400
print(id(a), id(b))
```

整型之间的运算：整型之间可以进行 +、-、*、/、%、//、**等运算。

a = 2
b = 3
print(a + b)    # 5
print(a - b)    # -1
print(a * b)    # 6
print(a / b)    # 0.6666666666666666
print(a // b)   # 0
print(a % b)    # 2
print(a ** b)   # 8

number = 15 # 0b1111
print(number.bit_length())  # 获取15的二进制数的位数  4

5.1.2 浮点型`float`

浮点型表示带有小数部分的数，如：

a = 3.14
b = -0.5
scientific_notation = 1.23e-4  # 科学计数法

浮点数的精度受限于计算机的浮点数表示方式，可能会出现精度误差。

v1 = 0.1
v2 = 0.2
print(v1 + v2) # 0.30000000000000004

如果想要得到精确的浮点数，可以使用【decimal模块】。如下：

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

【round函数的使用】：对浮点数进行四舍五入。

# 第二个参数为保留的小数位数
v1 = 3.1415926
result = round(v1, 3)
print(result) # 3.142

5.1.3 复数`complex`

以 a + bj 的形式表示，其中 a 是实部，b 是虚部，例如：

c = 1 + 2j
d = complex(3, 4)  # 使用 complex() 函数创建复数

5.1.4 `isdigit()`、`isdecimal()`、`isnumeric()`的区别

python中的数字包括unicode数字、bytes数字【也称半角数字】以及全角数字，其中unicode数字和全角数字属于字符串，而bytes数字属于bytes类型。

unicode数字：unicode 数字是以 Unicode 编码表示的字符数字，涵盖了全球不同语言和文化中的数字字符，如阿拉伯数字、罗马数字、汉字数字等。表示形式为u，如u'123456'，python中字符串默认为unicode字符串。

bytes数字：表示形式为b，如b'2546'。占用一个字节，通常用于存储二进制数据。

# byte数字
number = b'622'

print(number.isdigit()) # True
print(number.isdecimal())   # AttributeError: 'bytes' object has no attribute 'isdecimal'
print(number.isnumeric())   # AttributeError: 'bytes' object has no attribute 'isnumeric'

全角数字：与bytes数字的区别就是全角数字占用两个字节，本质上就是全角数字和半角数字的所用编码不同。

在 Python 中，isdigit()、isnumeric() 和 isdecimal() 都是字符串方法，用于判断字符串中是否包含特定类型的数字字符。然而，它们的适用范围和判断逻辑存在一些差异。

isdecimal()：判断数字字符串是否由十进制的0-9组成，且数字只能为非负数。常用于验证码校验。

# isdecimal()判断字符串是否为数字
print("1234".isdecimal())  # True
print("12.34".isdecimal())
print("¹²³".isdecimal())
print("１２３４".isdecimal())  # True
print("ⅠⅡⅢⅣⅤ".isdecimal())
print("①②③④⑤".isdecimal())
print("1/3".isdecimal())
print("¼".isdecimal())
print("0b1011".isdecimal())
print("0xAB".isdecimal())
print("1 2 3 4".isdecimal())
print("abc123".isdecimal())
print("@123".isdecimal())
print("一二三四".isdecimal())

isdigit()：适用范围比isdecimal更广，如阿拉伯数字、上标数字和圈码数字，不支持汉字字符或分数等扩展符号。

# isdigit()判断字符串是否为数字
print("1234".isdigit())  # True
print("12.34".isdigit())
print("¹²³".isdigit())  # True
print("１２３４".isdigit())  # True
print("ⅠⅡⅢⅣⅤ".isdigit())
print("①②③④⑤".isdigit())  # True
print("1/3".isdigit())
print("¼".isdigit())
print("0b1011".isdigit())
print("0xAB".isdigit())
print("1 2 3 4".isdigit())
print("abc123".isdigit())
print("@123".isdigit())
print("一二三四".isdigit())

isnumeric()：判断数字字符串是否由0 - 9、汉字数字、罗马数字、分数数字组成，且数字只能为非负数，其范围最广。

# isnumeric()判断字符串是否为数字
print("1234".isnumeric())  # True
print("12.34".isnumeric())
print("¹²³".isnumeric())  # True
print("１２３４".isnumeric())  # True
print("ⅠⅡⅢⅣⅤ".isnumeric())  # True
print("①②③④⑤".isnumeric())  # True
print("1/3".isnumeric())
print("¼".isnumeric())  # True
print("0b1011".isnumeric())
print("0xAB".isnumeric())
print("abc123".isnumeric())
print("@123".isnumeric())
print("一二三四".isnumeric())   # True

5.2 字符串`str`

字符串表示文本，是不可变序列，一旦创建，内容不可修改。

5.2.1 字符串的表示

字符串可以使用单引号、双引号、三引号括起来，其中单引号、双引号用来表示单行文本，三引号用来表示单行或多行文本。其中单行文本可以使用将较长的语句使用\连接，以提高代码可读性。

strs = "床前明月光，\
  疑是地上霜。"
print(strs)

'''
床前明月光，  疑是地上霜。
'''

strs = """床前明月光，
疑是地上霜"""
print(strs)

'''
床前明月光，
疑是地上霜。
'''

5.2.2 字符串之间的运算

字符串之间只能进行 +、*运算，如下：

str1 = "hello "
str2 = "python"
print(str1 + str2)  # 字符串的拼接，输出 hello python
print(str2 * 3) # 输出 pythonpythonpython

5.2.3 字符串常用方法

计算字符串的长度：len()

strs = "Bruce"
print(len(strs))    # 5

strs = "布鲁斯"
print(len(strs))    # 3

获取字符串指定索引处的字符：字符串能够通过索引取值，但是无法修改值。字符串中的索引从左到右从0依次递增，从右往左从-1依次递减。
```
strs = "Bruce"
print(strs[0])  # B
print(strs[-1])  # e
```

字符串切片：采用前取后不取的原则，默认步长为1，当步长为负值时可以实现倒序。

strs = "你好世界"
print(strs[0:2])    # 你好
print(strs[1:3])    # 好世
print(strs[:3])     # 你好世
print(strs[2:])     # 世界
print(strs[:])      # 你好世界

print(strs[1:-1])   # 好世
print(strs[-3:-1])  # 好世

strs = "hello python"
print(strs[0::2])   # hlopto 
print(strs[11:0:-1])    # nohtyp olle 
print(strs[::-1])   # nohtyp olleh

判断字符串是否以指定字符串开头、结尾，返回值为布尔值，startswith()、endswith()

strs = "重庆市巫溪县"
print(strs.startswith("重庆市"))   # 是否以"重庆市"开头，True
print(strs.endswith("巫溪"))  # 是否以"巫溪"结尾，strs以"巫溪县"结尾，返回False

字符串内容是否是十进制数，返回布尔值，isdecimal()
```
strs = "123456"
print(strs.isdecimal()) # True
```

去除字符串两端或一端的指定内容，默认去掉空格、换行符、制表符，strip()、lstrip()、rstrip()

strs = " 哈哈哈 "
print(strs.strip())     # 去除两端的空格，输入结果为"哈哈哈"
print(strs.lstrip())    # 去除左端的空格，输入结果为"哈哈哈 "
print(strs.rstrip())    # 去除右端的空格，输入结果为" 哈哈哈"

strings = "哈你好世界哈"
print(strings.strip("哈"))     # 去除两端的"哈"，输入结果为"你好世界"
print(strings.lstrip("哈"))    # 去除左端的"哈"，输入结果为"你好世界哈"
print(strings.rstrip("哈"))    # 去除右端的"哈"，输入结果为"哈你好世界"

# 用strip去除字符串两端指定内容时，只要字符串两端与指定内容有相同的字符都会被去除
strings = "哈你好世界哈"
print(strings.strip("你哈"))  # 输出"好世界"

字符串中的字母大小写转换，upper()、lower()

strs = "abCD"
print(strs.upper()) # 将字符串中的小写字母转换成大写，输出"ABCD"
print(strs.lower()) # 将字符串中的大写字母转换成小写，输出"abcd"

字符串中内容的替换，replace()

char_list = ["菜鸡", "不会玩", "别玩"]
content = input("请输入你想说的话：")    # 输入"菜鸡，你到底在玩什么，不会玩别玩"
for item in char_list:
    content = content.replace(item, "**")   # 将content中的item替换成**，输出"**，你到底在玩什么，*****"
print(content)

根据指定字符(或字符串)切割字符串，返回一个列表，split()、rsplit()

strs = "127.0.0.1"
print(strs.split("."))  # ['127', '0', '0', '1']
strs = "我哈哈你哈哈他"
print(strs.split("哈哈")) # ['我', '你', '他']

strs = "127.0.0.1"
print(strs.split(".", 2))   # ['127', '0', '0.1']，从左往右分割，找到前两个匹配的分隔符分割
print(strs.rsplit(".", 2))  # ['127.0', '0', '1']，从右往左分割，找到后两个匹配的分隔符分割

将字符串列表拼接成字符串，join()

str_list = ["你", "我", "他"]
print("_".join(str_list))   # 你_我_他

字符串转换为字节，encode()、decode()

strs = "床前明月光"
data = strs.encode("utf-8")
print(data)  # b'\xe5\xba\x8a\xe5\x89\x8d\xe6\x98\x8e\xe6\x9c\x88\xe5\x85\x89'
print(data.decode("utf-8"))  # 床前明月光

data = strs.encode("gbk")
print(data)  # b'\xb4\xb2\xc7\xb0\xc3\xf7\xd4\xc2\xb9\xe2'
print(data.decode("gbk"))  # 床前明月光

将字符串居中、居左、居右，center()、ljust()、rjust()

# 第一个参数为新字符串总长度，第二个参数为填充字符
strs = "Bruce"
print(strs.center(24, "-")) # ---------Bruce----------
print(strs.ljust(24, "-"))  # Bruce-------------------
print(strs.rjust(24, "-"))  # -------------------Bruce

填充0，zfill()，一般用于填充二进制数据

# 参数为新字符串总长度
strs = "Bruce"
print(strs.zfill(10))   # 00000Bruce

strs = "101"
print(strs.zfill(8))   # 00000101

5.2.4 原生字符串

使用原生字符串，可以避免字符串中转义字符的干扰。

strs = "你好\n世界"
print(strs)

'''
你好
世界
'''

strs = r"你好\n世界"
print(strs)

'''
你好\n世界
'''

5.3 布尔型`bool`

布尔型就两个值，一个True，一个False，主要用作逻辑判断。

print(1 == 2)   # False
print("123" == 123) # False
print(100 == 100) # True

password = input("请输入你的密码：")
if password == "123456":
    print("密码正确")
else:
    print("密码错误")

对于布尔型，有以下【注意点】：

字符串可以和整型比较相不相等，但是不能比较大小。
当一个条件表达式返回0、0.0或者是该条件表达式是空序列、None，则返回False。
布尔值可以和整型、浮点型进行运算，True为1，False为0。

python中的隐式转换：bool -> int -> float -> complex

5.4 列表`list`

列表list，是一个有序且可变的容器，可以存放多个不同类型的元素。

char_list = []  # 空列表
char_list = list()   # 空列表
char_list = [1, "name", 12.3]

list常用的方法如下：

追加，在原列表的末尾添加对象，append()

welcome = "欢迎来到***游戏".center(30, "-")
print(welcome)
user_count = 0
while True:
    count = input("请输入玩家人数：")
    if count.isdecimal():
        user_count = int(count)
        break
    else:
        print("输入格式错误，请重新输入！")
message = "{}人参加***人数".format(user_count)
player_list = []
for i in range(1, user_count + 1):
    player = input("请输入玩家({0}/{1})姓名：".format(i, user_count))   # mack jeck kelam iji
    player_list.append(player)

print(player_list)  # 'mack', 'jeck', 'kelam', 'jiji']

批量追加，将一个列表中元素逐一添加到另一个列表的结尾，extend()

name = ["jim", "Tom", "kio"]
point = [120, 320, 541]
name.extend(point)
print(name) # ['jim', 'Tom', 'kio', 120, 320, 541]
print(point)    # [120, 320, 541]，point不受影响

插入，insert()，当插入位置的索引值为负数时，会将该元素添加到列表第一个；如果插入位置的索引值大于或等于列表长度，则将该元素添加到列表结尾。

char_list = ["tom", "jane", "suor"]
char_list.insert(0, "liming")
print(char_list)    # ['liming', 'tom', 'jane', 'suor']

char_list = ["tom", "jane", "suor"]
char_list.insert(-5, "liming")
print(char_list)    # ['liming', 'tom', 'jane', 'suor']

char_list.insert(1000, "liming")
print(char_list)    # ['tom', 'jane', 'suor', 'liming']

根据值删除第一个匹配的元素，remove()

name_list = ["liming", "wangzhang", "liming", "vim"]
if "liming" in name_list:   
    # 当元素不在列表中时使用remove()时，程序会报错。
    name_list.remove("liming")
print(name_list)    # ["wangzhang", "liming", "vim"]

根据索引位置删除元素，pop()，返回值为删除的值

numbers = [1, 2, 3, 4, 5, 6]
numbers.pop()   # 默认删除列表中最后一个元素
print(numbers)  # [1, 2, 3, 4, 5]

print(numbers.pop(2))    # 3
print(numbers)  # [1, 2, 4, 5]

清空原列表，clear()

name = ["kim", "liming", "poly"]
name.clear()
print(name) # []

根据值获取索引，index()

name = ["kim", "liming", "poly"]
# 当列表中不存在"liming"时，使用index()时程序将会报错。
if "liming" in name:
    print(name.index("liming"))     # 1

列表的排序，sort()。当列表中的元素无法进行排序时，使用sort()程序将会报错。

numbers = [54, 12, 6, 32, 45, 12, 63]
numbers.sort()  # 默认reverse=False，从小到大进行排序
print(numbers)  # [6, 12, 12, 32, 45, 54, 63]

numbers = [54, 12, 6, 32, 45, 12, 63]
numbers.sort(reverse=True)  # 从大到小进行排序
print(numbers)  # [63, 54, 45, 32, 12, 12, 6])

# 字符串比较大小的原理，首先将每个元素的每个字符转换成unicode编码，然后再比较unicode编码大小进行排序。
strs = ["钟馗", "张飞", "汉钟离", "李白"]
strs.sort()
print(strs)  # ['张飞', '李白', '汉钟离', '钟馗']

反转原列表，reverse()

strs = ["钟馗", "张飞", "汉钟离", "李白"]
strs.reverse()
print(strs)  # ['李白', '汉钟离', '张飞', '钟馗']

列表的加法、乘法

加法：两个列表相加会拼接成一个新的列表。

乘法：一个列表乘以一个整数，等于将原列表创建n份再拼接。

list_1 = [25, 32, 54, 669, 21]
list_2 = [54, 65, 32, 12, 23]
print(list_1 + list_2)  # [25, 32, 54, 669, 21, 54, 65, 32, 12, 23]
print(list_1 * 2)  # [25, 32, 54, 669, 21, 25, 32, 54, 669, 21]

运算符in的使用

# 这种方式效率很慢，当列表元素很少时可以使用，否则尽量不要使用。
strs = ["li", "zhang", "hong", "ol"]
if "ol" in strs:
    print("ol在列表中")
else:
    print("ol不在列表中")

获取列表长度，len()

lists = [25, 32, 54, 669, 21]
print(len(lists))   # 5

列表中索引以及切片的使用与字符串基本一致，由于列表是可变类型，可以通过索引更改列表元素。

numbers = [1, 23, 65, 6, 54]
del numbers[0]  # 可以通过del删除列表元素
print(numbers)  # [23, 65, 6, 54]
numbers[0:2] = [10, 10]
print(numbers)  # [10, 10, 6, 54]

user_list = ["小明", "小红", '小刚']

print(user_list[0:2])  # ["小明","小红"]
print(user_list[1:])
print(user_list[:-1])
# 改
user_list = ["小明", "小红", '小刚']
user_list[0:2] = [11, 22, 33, 44]
print(user_list)  # 输出 [11, 22, 33, 44, '小刚']

user_list = ["小明", "小红", '小刚']
user_list[2:] = [11, 22, 33, 44]
print(user_list)  # 输出 ['小明', '小红', 11, 22, 33, 44]

user_list = ["小明", "小红", '小刚']
user_list[3:] = [11, 22, 33, 44]
print(user_list)  # 输出 ['小明', '小红', '小刚', 11, 22, 33, 44]

# 当索引值超出列表索引范围时，程序并不会报错，而是可以进行相关的操作
user_list = ["小明", "小红", '小刚']
user_list[10000:] = [11, 22, 33, 44]
print(user_list)  # 输出 ['小明', '小红', '小刚', 11, 22, 33, 44]

user_list = ["小明", "小红", '小刚']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list)  # 输出 [11, 22, 33, 44, '小红', '小刚']
# 删
user_list = ["小明", "小红", '小刚']
del user_list[1:]
print(user_list)  # 输出 ['小明']

user_list = ["小明", "小红", '小刚']
print(user_list[::-1])  # ['小刚', '小红', '小明']

列表与for循环

# 错误方式
user_list = ["刘赛", "李四", "刘班", '刘赵四', "小宝", "刘山"]
for item in user_list:  # 结果并不是我们想要的, for循环通过in在列表中拿取元素, 是依次通过索引0,1,2,3拿取的。而列表是可变元素，当删除元素时列表元素的位置也发生了改变, 而for循环并不知道，还是按照索引拿取，因此会造成部分元素跳过未访问到
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)    # ['李四', '刘赵四', '小宝']

# 正确方式: 倒着删
user_list = ["刘赛", "李四", "刘班", '刘赵四', "小宝", "刘山"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)    # ['李四', '小宝']

列表的转换：整型、浮点型、布尔型无法转换成列表，编译器会报错，序列可以转换成列表。

# 元组转换成列表
tuples = ("哈哈", "喜喜", "丫丫")
tuple_list = list(tuples)
print(tuple_list)  # ['哈哈', '喜喜', '丫丫']

# 集合转换成列表
sets = {"哈哈", "喜喜", "丫丫"}
set_list = list(sets)
print(set_list)  # ['丫丫', '哈哈', '喜喜']，集合是无序的

# 字符串转换成列表，意义不大，开发中几乎不用
strs = "你好世界"
str_list = list(strs)
print(str_list)  # ['你', '好', '世', '界']

列表的嵌套：列表也可以嵌套使用

data = ["小李", ["小花", "小红"], True, [11, 22, [999, 123], 33, 44], "小龙"]

print(data[0])  # "小李"
print(data[1])  # ["小花","小红"]
print(data[0][1])  # "李"
print(data[1][-1])  # "小红"

data.append(666)
print(data)  # [ "小李",["小花","小红"],True,[11,22,33,44],"小龙",666]

data[1].append("小高")
print(data)  # [ "小李",["小花","小红","小高"],True,[11,22,33,44],"小龙",666 ]

del data[-2]
print(data)  # [ "小李",["小花","小红","小高"],True,[11,22,33,44],666 ]

data[-2][1] = "小天"
print(data)  # [ "小李",["小花","小红","小高"],True,[11,"小天",33,44],666 ]

data[1][0:2] = [999, 666]
print(data)  # [ "小李",[999,666,"小高"],True,[11,"小天",33,44],666 ]

5.5 元组`tuple`

元组是有序、不可变容器，可以存放多个不同类型的元素。元组的使用方法与列表基本上一致，序列可以转换成元组。

# 当元组里面只有一个元素时，不加逗号python解释器不会将其当作元组处理
tuples = ()     # 空元组
tuples = tuple()    #  空元组
a = (1)
print(type(a))  # <class 'int'>
b = (1,)
print(type(b))  # <class 'tuple'>

a = ((1), (2), (3)) # (1, 2, 3)，元素是三个整型
a = ((1,), (2,), (3,)) # 元素是三个元组

5.6 集合`set`

集合，是一个无序、可变、元素不允许重复的容器，可以存放多个不同类型的元素。

sets = set()    # 空集合
sets = {1, 2, 4, "Bruce"}

set的常用方法如下：

添加元素，add()

sets = set()
sets.add("12")
sets.add("38")
sets.add("12")
print(sets)  # {'38', '12'}，不允许存在重复的值，每次输出的结果可能顺序不同，因为集合是无序的

删除元素，discard()

names = {"tom", "bruce", "jim"}
names.discard("tom")
print(names)    # {'jim', 'bruce'}

交集、并集、差集

# 交集
s1 = {"1", "2", "3"}
s2 = {"1", "3", "4"}
s3 = s1 & s2  # 取两个集合的交集
print(s3)

# 并集
s1 = {"1", "2", "3"}
s2 = {"1", "3", "4"}
s3 = s1 | s2   			# 取两个集合的并集
print(s3)

# 差集
s1 = {"1", "2", "3"}
s2 = {"1", "3", "4"}

s3 = s1 - s2  # 差集，s1中有且s2中没有的值
s4 = s2 - s1  # 差集，s2中有且s1中没有的值

print(s3, s4)

计算长度，len()

var = {"jim", "lij", "klo"}
print(len(var)) # 3

集合由于是无序的，因此没有索引、切片等操作。
序列都可以转换成集合，达到去重的效果。

集合的底层采用哈希表存储元素，所以集合的元素必须是可哈希的元素，而list/set是不可哈希的，因此集合的元素只能是str/int/bool/tuple类型的元素。

v1 = [11,22,["Bruce","Jane"],33]
v2 = set(v1) # 报错 
print(v2) 

data_list = [
    "Bruce",
    11,
    (11, 22, 33, {"Bruce", "Mali"}, 22),
    [11, 22, 33, 22],
    {11, 22, (True, ["中国", "北京"], "沙河"), 33}]
a = set(data_list)  # 程序报错，只要包含了set、list就不能转换成集合

集合查找速度较列表、元组特别快，因为底层是哈希表结构。
True和False在计算机中底层就是1和0，因此在集合中同时出现1和True、0和False时会算作重复值。
```
data = {0, False, 1, True}
print(data) # {0, 1}
```

5.7 字典`dict`

字典，是有序、键不重复的键值对的可变类型的容器，键重复则会覆盖，在python3.6之前字典就是无序的。键必须可哈希int/str/tuple/bool，值可以是任意类型。当键同时出现1和True、0和False时会算作重复值，会被覆盖。

dicts = {}  # 空字典
dicts = dict()  # 空字典
dicts = {
    "tom": 20,
    "jim": 18
}

dict常用的方法如下：

获取指定键的值，get()

info = {
    "age": 12,
    "status": True,
    "name": "Bruce",
    "data": None
}

data1 = info.get("name")
print(data1)  # Bruce

data2 = info.get("age")
print(data2)  # 12

data = info.get("email")  # 键不存在，默认返回 None
print(data) # None

data = info.get("email", 123)  # 键不存在，默认返回 None
print(data)  # 123，指定不存在的键"email"的值为12

获取所有的键，keys()

info = {"age": 12, "status": True, "name": "Bruce", "email": "xx@qq.com"}
data = info.keys()
print(data)  # dict_keys(['age', 'status', 'name', 'email']), 不是列表, 但是可以转换成列表

result = list(data)
print(result)  # ['age', 'status', 'name', 'email']

info = {"age":12, "status":True, "name":"Bruce","email":"xx@qq.com"}
# 不转换成列表也可以通过in访问
for ele in info.keys():
    print(ele)

获取所有的值，values()

info = {"age":12, "status":True, "name":"Bruce","email":"xx@qq.com"}
data = info.values()
   
print(data) # 输出：dict_values([12, True, 'Bruce', 'xx@qq.com'])

获取所有的键值，items()

info = {"age":12, "status":True, "name":"Bruce","email":"@qq.com"}
data = info.items()
# 也是返回一个高仿列表
print(data) # 输出 dict_items([ ('age', 12),  ('status', True),  ('name', 'Bruce'),  ('email', 'xx@qq.com')  ])

info = {"age":12, "status":True, "name":"Bruce","email":"xx@qq.com"}
for item in info.items():
    print(item[0],item[1]) # item是一个元组 (键，值)
for key,value in info.items():
    print(key,value)

新增键值对，setdefault()

dicts = {"tom": 18, "jim": 8}
dicts.setdefault("kom", 18) # 如果没有"kom"，则添加键值对。如果已经存在，则不做任何操作
print(dicts)   # {'tom': 18, 'jim': 8, 'kom': 18}

dicts.setdefault("tom", 85)
print(dicts)    # {'tom': 18, 'jim': 8, 'kom': 18}

更新键值对，update()

info = {"age":12, "status":True}
info.update( {"age":14,"name":"Bruce"} )   # info中没有的键直接添加，有的键则更新值
print(info) # 输出：{"age":14, "status":True,"name":"Bruce"}

移除指定键值对，pop()

info = {"age":12, "status":True,"name":"Bruce"}
data = info.pop("age")
print(info) # {"status":True,"name":"Bruce"}
print(data) # 12

移除最后一个键值对，popitem()

info = {"age":12, "status":True,"name":"Bruce"}
data = info.popitem() # ("name","Bruce" )，返回一个元组
   
print(info) # {"age":12, "status":True}
print(data) # ("name","Bruce")

获取字典的长度，len()

根据键访问、修改键值对【开发中常用】

# 获取值
info = {"age": 12, "status": True, "name": "Bruce"}
print(info["age"])  # 12，当想要访问的键不存在时，程序会报错
# 新增值
info["gender"] = "男"
print(info) # 输出： {"age":12, "status":True,"name":"Bruce","gender":"男"}
# 修改值
info["age"] = 20
print(info) # {"age":20, "status":True,"name":"Bruce","gender":"男"}
# 删除键值对
del info["age"]
print(info) # {"status":True,"name":"Bruce","gender":"男"}，当删除的键值对不存在时，程序会报错

字典的转换，很少使用，当将一个字典转换成list/tuple时只会处理字典的键。

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

v = dict((("k1", "v1"), ("k2", "v2")))
print(v) # { "k1":"v1", "k2":"v2" }

字典元素的存储也是采用了哈希表结构。

5.8 空值

None表示空值，相当于Java中null，可以释放内存。

v1 = None
v2 = None   # 不会开辟内存

v1 = [11,22,33,44]
v2 = [111,22,43]
v1 = None # 释放v1的内存

6. 可变类型与不可变类型

6.1 可变类型

可变类型的对象在创建后可以被修改，这意味着这个对象的内存地址不会发生改变。Python中的可变类型包括list、dict、set。

a = [1, 2, 3]
print(id(a))    # 2092201407424
a.pop()
print(id(a))    # 2092201407424

6.2 不可变类型

不可变类型的数据创建后，其值就不能被改变。也就是说，一旦你创建了一个不可变类型的对象，你就不能再改变它的内容，如果改变它的内容，实际上是指向了一个新的对象，内存地址发生改变。Python中的不可变类型包括数字、str、tuple、bool。

a = 12.3
print(id(a))    # 1340125363024
a = 14.5
print(id(a))    # 1340125362704

7. 常见内置函数的使用

7.1 `id`、`type`、`isinstance`、`del`

id()：获取变量保存的地址。
type()：获取变量的数据类型。
isinstance(obj, class)：判断对象obj是否为class类型。
del：删除变量。

strs = "Bruce"
print(id(strs))    # 2477905283568
print(type(strs))   # <class 'str'>
print(isinstance(strs, int))    # False
del strs

7.2 `chr`、`ord`

chr()和ord()都是python中的内置函数，用于字符与unicode编码的转换。

chr()：用于将一个Unicode编码转换为对应的字符。

ord()：用于将一个字符转换为对应的Unicode编码。

var = ord("中")
print(var)  # 20013
print(chr(var))  # 中

8. `python`中的对象

python中万物皆对象，包括但不限于字面值、函数等。对象是内存中存储数据的实体，具有明确的类型。变量只是作为对象的引用，实际上保存着所指对象的内存地址。一个对象的内存地址id是唯一的。对象的组成结构如下：

id：对象的唯一标识
type：对象的类型
value：对象的值

比较两个对象是否相等，要注意is和==的区别，如下：

is / is not：比较两个对象的id是否相等

== / !=：比较两个对象的值是否相等

a = 10
b = 10
print(a == b)   # True
print(a is b)   # True

9. 进制间的转换

9.1 十进制数转换成二进制、八进制、十六进制

print(bin(22))  # 二进制
print(oct(22))  # 八进制
print(hex(22))  # 十六进制

9.2 二进制、八进制、十六进制转换为十进制数

将字符串转换为十进制数

# 默认按十进制将字符串转换为int
i1 = int("0b010110", base=2)    # 二进制转换为十进制
i2 = int("0o25", base=8)    # 八进制转换为十进制
i3 = int("0x6f", base=16)   # 十六进制转换为十进制
i4 = int("120", base=10)    # 十进制转换为十进制
print(i1, i2, i3)

# 当将二进制、八进制、十六进制数赋值给变量时，python解释器会自动将其转换为十进制数
i1 = int(0b010110)    # 二进制转换为十进制
i2 = int(0o25)    # 八进制转换为十进制
i3 = int(0x6f)   # 十六进制转换为十进制
print(i1, i2, i3)

10. 运算符

运算符的优先级：算术运算符 > 比较运算符 > 逻辑运算符 (not > and > or)

10.1 算数运算符

+、-、*、/、//、**、%

a = 2
b = 3
print(a + b)    # 5
print(a - b)    # -1
print(a * b)    # 6
print(a / b)    # 0.6666666666666666
print(a // b)   # 0
print(a % b)    # 2
print(a ** b)   # 8

10.2 比较运算符

==、!=、>、<、>=、<=

print(1 == 1)   # True
print(5 >= 4)   # True
print(3 < 5 > 4)    # True
print(1 < 2 < 3)    # True
print(3 > 1 < 2)    # True

注意点：python中可以连续比较，如1 < 5 < 6、3 > 1 < 2等。

10.3 赋值运算符

=、+=、-=、*=、/=、//=、**=、%=

连续赋值：a = b = c = 100
拆包式赋值：a, b, c = 100, "Bruce", True

10.4 逻辑运算符

and、or、not

print(1 > 0 and 2 > 3)  # False
print(5 > 10 or 3 > 2)  # True
print(not 3 > 0)    # False

逻辑运算符在实际开发中，会碰到以下两种情况。

当and、or左右表达式结果为True或者False时：

var = "111" == 111 and 5 == 5
print(var)  # False

当and、or左右表达式结果不为True或者False时：
- 首先将and / or前后的值转换为布尔值。
- 再看本次结果取决于谁就返回谁的值。
```
var1 = "" and 123
print(var1) # var1 == ""

var2 = "" or 500
print(var2) # var2 == 500

var3 = 0 and 5
print(var3) # var3 == 0
```

10.5 位运算符

|、&、^、~、<<、>>

& ：按位与运算，都为1为1，否则为0。
|：按位或运算，都为0为0，否则为1。
^：按位异或：相同为0，否则为1。
~：按位取反：0为1，1为0。
<<：左移运算，左移n位相当于乘以2^n。

>>：右移运算，右移n位相当于除以2^n。

number = 4
print(number << 1)  # 8
print(number << 2)  # 16
print(number >> 1)  # 2
print(number >> 2)  # 1

10.6 成员运算符

in、not in

number_list = [1, 2, 5, 4, 5]
if 6 in number_list:
	print("6在该列表中")
else:
	print("6不在该列表")

10.7 身份运算符

is、is not

a = 1
b = 1
print(a is b)	# True

10.8 三目运算符

表达式1 if 条件表达式 else 表达式2

a = 5
b = 10
max_value = a if a > b else b
print(max_value)  # 输出 10

11. 流程控制语句

选择语句、循环语句

11.1 选择语句

选择语句分为【单分支语句】、【双分支语句】、【多分支语句】。

单分支语句

salary = 8000
if salary >= 5000:
    print("你的收入已经达到了中高收入人群")

双分支语句

password = input("请输入你的密码：")
if password == "20041104":
    print("密码正确")
else: 
    print("密码错误")

多分支语句

point = int(input("请输入你的分数："))
if 0 < point < 60:
    print("E")
elif 60 <= point < 70:
    print("D")
elif 70 <= point < 80:
    print("C")
elif 80 <= point < 90:
    print("B")
elif 90 <= point <= 100:
    print("A")
else:
    print("你输入的成绩无效")

11.2 循环语句

while、for语句

11.2.1 `break`和`continue`

break：结束当前循环。如果循环嵌套，break只会结束离它最近的循环。
continue：跳过本次循环。

11.2.2 `while`语句与`while...else...`语句

死循环
```
while True:
    print("hello python")
```

使用break终止循环

count = 0
while True:
    print("hello python")
    count += 1
    if count == 100:
        break

使用continue输出100以内的偶数

number = 100
while number:
    if number % 2 == 0:
        print(number)
    number -= 1

嵌套循环中使用break

# 输出1后一直输出2，执行print(1)后会进入死循环一直执行print(2)
while True:
    print(1)
    while True:
        print(2)

# 会一直输出1212121212...执行print(1)后进入内层循环，执行print(2)，然后执行break跳出内层循环，继续执行外层循环中的print(1)，一直这样反复下去，构成一个死循环。
while True:
    print(1)
    while True:
        print(2)
        break

while...else...语句：当循环正常执行完后，将会执行else中的语句。如果循环是被break终止的话，将不会执行else中的语句。

flag = 10
while flag:
    print(flag, end=" ")
    flag -= 1
else:
    print("程序结束")

# 10 9 8 7 6 5 4 3 2 1 程序结束

flag = 10
while flag:
    print(flag, end=" ")
    flag -= 1
    if flag == 5:
        break
else:
    print("程序结束")

# 10 9 8 7 6

11.2.3 `range`函数

range函数是python中的内置函数，用于生成一个整数序列，可以指定步长，也是采用前取后不取原则。

range(10)   # [0,1,2,3,4,5,6,7,8,9]
range(2,10) # [2,3,4,5,6,7,8,9]
range(1,10,2)   # [1,3,5,7,9]
range(10,1,-1) # [10,9,8,7,6,5,4,3,2]

11.2.4 `for`循环与`for...else...`语句

char_list = ["java", "python", "php"]
for item in char_list:
    print(item, end=" ")    # java python php

for i in range(1,10,2):
    print(i, end=" ")   # 1 3 5 7 9

for i in range(10):
    print(i)
else:
    print('正常执行完毕')	# 会输出
    
    
for i in range(10):
    print(i)
    if i == 5:
        break
else:
    print('正常执行完毕') 	# 不会输出，与while...else...同理