python基础知识
基础概念
1. 输出函数print()
支持三种类型：数字、字符串、运算表达式
print(1,"hello # world",1+2)
2. 注释
- 可用于解释 Python 代码。
- 可用于提高代码的可读性。
- 在测试代码时，可以使用注释来阻止执行。
单行注释：
#This is a comment
print("Hello, World!")
行内注释：
print("Hello, World!") #This is a comment
阻止执行：
#print("Hello, World!")
多行注释：
"""
This is a comment
written in
more than just one line
"""
3. Python 变量
变量是存放数据值的容器。
与其他编程语言不同，Python 没有声明变量的命令。
变量名称
变量可以使用短名称（如 x 和 y）或更具描述性的名称（age、carname、total_volume）。
Python 变量命名规则：
变量名必须以字母或下划线字符开头
变量名称不能以数字开头
变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）
请记住，变量名称区分大小写
x = 10
print(x)
x = "Bill"
print(x)
向多个变量赋值:
x,y,z = "Orange", "Banana", "Cherry"
print(x,y,z)
x = y = z = "Orange"
print(x,y,z)
变量拼接：
x = "awesome"
print("Python is " + x)
尝试组合字符串和数字，Python 会给出错误：
x = 10
y = "Bill"
print(x + y)
TypeError: can only concatenate str (not "int") to str
print(x,y)
全局变量
x = "awesome"
def myfunc():
print("Python is " + x)
myfunc()
在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用。具有相同名称的全局变量将保留原样，并拥有原始值。
x = "awesome"
def myfunc():
x = "fantastic"
print("Python is " + x)
myfunc()
print("Python is " + x)
global 关键字
要在函数内部创建全局变量，您可以使用 global 关键字。
def myfunc():
global x
x = "fantastic"
myfunc()
print("Python is " + x)
4. Python 数据类型
Python 默认拥有以下内置数据类型：
| 文本类型： | str |
| 数值类型： | int, float, complex复数 |
| 序列类型： | list, tuple, range |
| 映射类型： | dict |
| 集合类型： | set, frozenset |
| 布尔类型： | bool |
| 二进制类型： | bytes, bytearray, memoryview |
获取数据类型
用type()函数获取任何对象的数据类型：
x = b"Hello"
print(type(x)) #<class 'bytes'>
设置数据类型
| 示例 | 数据类型 |
|---|---|
| x= "Hello World" | str |
| x= 29 | int |
| x= 29.5 | float |
| x= 10+1j | complex 复数（含有符号j的表达式） |
| x= ["apple", "banana", "cherry"] | list |
| x= ("apple", "banana", "cherry") | tuple |
| x= range(6) | range |
| x= | dict |
| x= | set |
| x= frozenset({"apple", "banana", "cherry"}) | frozenset |
| x= True | bool |
| x= b"Hello" | bytes |
| x= bytearray(5) | bytearray |
| x= memoryview(bytes(5)) | memoryview |
设定特定的数据类型
如果希望指定数据类型，则您可以使用以下构造函数：
| 示例 | 数据类型 |
|---|---|
| x = str("Hello World") | str |
| x = int(29) | int |
| x = float(29.5) | float |
| x = complex(1j) | complex |
| x = list(("apple", "banana", "cherry")) | list |
| x = tuple(("apple", "banana", "cherry")) | tuple |
| x = range(6) | range |
| x = dict(name="Bill", age=36) | dict |
| x = set(("apple", "banana", "cherry")) | set |
| x = frozenset(("apple", "banana", "cherry")) | frozenset |
| x = bool(5) | bool |
| x = bytes(5) | bytes |
| x = bytearray(5) | bytearray |
| x = memoryview(bytes(5)) | memoryview |
range类型的有点在于：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop,step三个值。只有当调用range对象时，才会计算。
可以使用运算符in(not in)
5. Python 数字
Python中有三种数字类型：
- int 整数：正数或负数，没有小数
- float 浮点数：包含小数的正数或负数;也可以是带有“e”的科学数字，表示 10 的幂
- complex 负数
计算机采用二进制存储浮点数时是不准确的，可能会产生误差，因此需要格外注意
print(1.1 + 2.2 -3.3)
解决方案1：导入模块decimal
from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2'))
解决方案2：导入模块fractions,（用于计算分数和浮点数）
from fractions import Fraction
print(Fraction(11,10) + Fraction(22,10))
x = 10 #int
y = 6.3 #float
y1 = 27e4 #float 270000
y2 = -49.8e100 #float -4.98e101
z = 10 + 2j #complex
print(type(x),type(y),type(z))
#查看复数的实部和虚部
print(z.real,z.imag)
可以使用 int()、float() 和 complex() 方法从一种类型转换为另一种类型：
x = 10
print(type(x),int(x),complex(x),float(x)) #<class 'int'> 10 (10+0j) 10.0
随机数
Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：
import random
print(random.randrange(1,10))
6. Python数据类型转换（Casting）
使用构造函数完成在 python 中的转换：
- int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字的字符串字面量
- float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
- str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量
整数：
x = int(1)
y = int(2.5)
z = int("3")
print(x,y,z) #1 2 3
浮点数：
x = float(1)
y = float(2.5)
z = float("3")
w = float("3.56")
print(x,y,z,w) #1.0 2.5 3.0 3.56
如果想保留两位小数：
a = 3.141592653
print(round(a,2),"%.2f" % a) #使用round内置函数或者字符串格式化
字符串：
x = str("S2")
y = str(3)
z = str(4.0)
print(x,y,z) #S2 3 4.0
整数的不同进制表示
- 10进制：默认进制
- 2进制：0b开头
- 8进制：0o开头
- 16进制：0x开头
print(118) #118
print(0b1110110) #118
print(0o166) #118
print(0x76) #118
整数转换为不同进制的字符串
- bin():将十进制转换成2进制字符串，binary
- oct():将十进制转换成8进制字符串，octal
- hex():将十进制转换成16进制字符串，hexadecimal
print(bin(118)) #0b1110110
整数的创建
第一个参数为字符串，第二个参数为指定进制
print(int('1110110',2))
print(int('0o166',8))
7. Python字符串
多行字符串
使用三个引号将多行字符串赋值给变量：
a = """Python is a widely used general-purpose, high level programming language.
It was initially designed by Guido van Rossum in 1991
and developed by Python Software Foundation. """
print(a)
或者三个单引号
a = '''Python is a widely used general-purpose, high level programming language.
It was initially designed by Guido van Rossum in 1991
and developed by Python Software Foundation. '''
print(a)
字符串是字节数组
Python 没有字符数据类型，单个字符就是长度为 1 的字符串。
a = "Hello, World!"
print(a[1]) #e
裁切:
print(a[2:5]) #llo
负的索引:
print(a[-6:-2]) #Worl
字符串长度:
print(len(a)) #13
字符串内置方法
a = " Hello, World! "
print(a) # Hello, World!
strip() 方法删除开头和结尾的空白字符： # strip:剥夺vt;长条，带子，条子n
print(a.strip()) #Hello, World!
lower() 返回小写的字符串：
print(a.strip().lower()) #hello, world!
upper() 方法返回大写的字符串：
print(a.strip().upper()) #HELLO, WORLD!
replace() 用另一段字符串来替换字符串：
print(a.replace(" ", "")) #Hello,World!
print(a.strip().replace("World","Python")) #Hello, Python!
split() 方法在找到分隔符的实例时将字符串拆分为子字符串：
print(a.strip().split(",")) #['Hello', ' World!']
检查字符串中是否存在特定短语或字符，可以使用 in 或 not in 关键字:
x = "llo" in a
y = "xxx" not in a
print(x,y) #True True
字符串级联（串联）
如需串联或组合两个字符串，您可以使用 + 运算符。
b = "very good"
print(a.strip() + b) #Hello, World!very good
print(a.strip() + " And it's " + b) #Hello, World! And it's very good
age = 36
txt = "My name is Bill, I am " + age
print(txt)
#类型不同报错
#TypeError: can only concatenate str (not "int") to str
使用 format() 方法组合字符串和数字：
format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：
age = 63
txt = "My name is Bill, and I am {}"
print(txt.format(age))
#My name is Bill, and I am 63
age = 54
name = "lily"
high = "1.67"
print("My name is {}, and I am {} years old , I am {} tall.".format(name,age,high))
#My name is lily, and I am 54 years old , I am 1.67 tall.
可以使用索引号 {0} 来确保参数被放在正确的占位符中：
quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))
#I want to pay 49.95 dollars for 3 pieces of item 567.
Python其他内建方法。
注释：所有字符串方法都返回新值。它们不会更改原始字符串。
a = "Hello,World"
print(a.casefold()) #hello,world 把字符串转换为小写。
print(a.lower()) #hello,world 把字符串转换为小写。
print(a.capitalize()) #Hello,world 把首字符转换为大写。
print(a.swapcase()) #hELLO,wORLD 切换大小写，小写成为大写，反之亦然。
print(a.center(20)) # Hello,World | 返回居中的字符串。
print(a.count("hello")) #1 返回指定值在字符串中出现的次数。
.lower(): 这是字符串对象的内置方法，它将字符串中的所有字符转换为小写形式，并返回一个新的字符串。这个方法使用的是默认的小写转换规则，这意味着它可能不适用于所有的语言和字符集。例如，对于某些特殊字符或非英语字符，.lower()方法可能不会正确地进行转换。.casefold(): 这也是字符串对象的内置方法，它执行一种更加严格和全面的小写转换。它将字符串中的字符转换为小写形式，并应用一些额外的规则，以处理特殊字符和非英语字符。.casefold()方法更适合于进行字符串比较和处理，因为它提供了更一致和准确的结果。
| 方法 | 描述 |
|---|---|
| capitalize() | 把首字符转换为大写。 |
| casefold() | 把字符串转换为小写。 |
| center() | 返回居中的字符串。 |
| count() | 返回指定值在字符串中出现的次数。 |
| encode() | 返回字符串的编码版本。 |
| endswith() | 如果字符串以指定值结尾，则返回 true。print(str1.endswith("china")) # True |
| expandtabs() | 设置字符串的 tab 尺寸。 |
| find() | 在字符串中搜索指定的值并返回它被找到的位置。 |
| format() | 格式化字符串中的指定值。(通过索引或名称来替换占位符。) |
| format_map() | 格式化字符串中的指定值。(通过映射对象的键来替换占位符。)常用于引用dict |
| index() | 在字符串中搜索指定的值并返回它被找到的位置。 |
| isalnum() | 如果字符串中的所有字符都是字母数字，则返回 True。 |
| isalpha() | 如果字符串中的所有字符都在字母表中，则返回 True。 |
| isdecimal() | 如果字符串中的所有字符都是小数，则返回 True。 |
| isdigit() | 如果字符串中的所有字符都是数字，则返回 True。 |
| isidentifier() | 如果字符串是标识符，则返回 True。 |
| islower() | 如果字符串中的所有字符都是小写，则返回 True。 |
| isnumeric() | 如果字符串中的所有字符都是数，则返回 True。 |
| isprintable() | 如果字符串中的所有字符都是可打印的，则返回 True。 |
| isspace() | 如果字符串中的所有字符都是空白字符，则返回 True。 |
| istitle() | 如果字符串遵循标题规则，则返回 True。 |
| isupper() | 如果字符串中的所有字符都是大写，则返回 True。 |
| join() | 把可迭代对象的元素连接到字符串的末尾。 |
| ljust() | 返回字符串的左对齐版本。 |
| lower() | 把字符串转换为小写。 |
| lstrip() | 返回字符串的左修剪版本。 |
| maketrans() | 返回在转换中使用的转换表。 |
| partition() | 返回元组，其中的字符串被分为三部分。 |
| replace() | 返回字符串，其中指定的值被替换为指定的值。 |
| rfind() | 在字符串中搜索指定的值，并返回它被找到的最后位置。 |
| rindex() | 在字符串中搜索指定的值，并返回它被找到的最后位置。 |
| rjust() | 返回字符串的右对齐版本。 |
| rpartition() | 返回元组，其中字符串分为三部分。 |
| rsplit() | 在指定的分隔符处拆分字符串，并返回列表。 |
| rstrip() | 返回字符串的右边修剪版本。 |
| split() | 在指定的分隔符处拆分字符串，并返回列表。 |
| splitlines() | 在换行符处拆分字符串并返回列表。 |
| startswith() | 如果以指定值开头的字符串，则返回 true。 |
| strip() | 返回字符串的剪裁版本。 |
| swapcase() | 切换大小写，小写成为大写，反之亦然。 |
| title() | 把每个单词的首字符转换为大写。 |
| translate() | 返回被转换的字符串。 |
| upper() | 把字符串转换为大写。 |
| zfill() | 在字符串的开头填充指定数量的 0 值。 |
部分方法展示：
.encode
str1 = "你好，china"
str2 = "123"
str = "hello"
print(str1.encode(),str2.encode(),str.encode())
# b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8cchina' b'123' b'hello'
.expandtabs()这个方法在处理字符串中的制表符并进行对齐时非常有用:
a = "hello\tworld"
print(a)
#hello world
print(a.expandtabs()) # \t代表一个字符，默认情况下每个制表符将扩展为8个空格
#hello world
print(a.expandtabs(2))
#hello world
.find():
a = "hello,world"
print(a.find("or")) #7
print(a.find("xxx")) # -1 .find()方法返回-1，表示未找到
.format_map()
data = {'name': 'Alice', 'age': 25, 'hight': 3.6 , 'weight' : 50}
s = 'My name is {name} and I am {age} years old.I am {hight} tall,weight {weight}'
formatted = s.format_map(data)
print(formatted)
.format()
name = "Alice"
age = 25
hight = 3.6
weight = 50
s = 'My name is {} and I am {} years old.I am {} tall,weight {}'
print(s.format(name,age,hight,weight))
'''
主要区别：
- format_map() 使用映射对象作为参数，通过映射对象的键值对来替换占位符。
- format() 使用位置参数和关键字参数作为参数，通过索引或名称来替换占位符。
'''
.str.maketrans(x, y, z)
参数：
x：需要转换的字符或字符序列。
y：与 x 对应的字符或字符序列，用于指定替换规则。
z：指定要删除的字符或字符序列。
a = 'apple,I like eating!'
trans_table = a.maketrans("a","不，你不想！")
#ValueError: the first two maketrans arguments must have equal length
trans_table = a.maketrans("I","U")
print(a.translate(trans_table))
#apple,U like eating!
# 创建一个转换表，删除所有的数字字符
s = 'abc123def456'
trans_table = str.maketrans('', '', '0123456789')
print(s.translate(trans_table))
#abcdef
trans_table = str.maketrans('', '', 'abcde0123456789')
print(s.translate(trans_table))
#f
.partition(separator)
separator：分隔符字符串，用于将原始字符串分割成三部分。
s = 'abc123def412356'
print(s.partition("12")) #从左边开始搜索分隔符。
#('abc', '12', '3def412356')
print(s.rpartition("12")) #从右边开始搜索分隔符。
#('abc123def4', '12', '356')
print(s.partition("000"))
#('abc123def412356', '', '')
rstrip() 方法常用于处理从外部数据源读取的字符串，去除末尾的空格或其他不需要的字符，以便进行后续的处理或比较。
如果未提供 characters 参数，默认会去除末尾的空格字符。
s = "Hello, World! "
result = s.rstrip()
print(result) # 输出: "Hello, World!"
s = "Python is fun!!!"
result = s.rstrip("!")
print(result) # 输出: "Python is fun"
s = " Spaces "
result = s.rstrip()
print(result) # 输出: " Spaces"
s = "ABCDEF"
result = s.rstrip("DEF")
print(result) # 输出: "ABC"
s = "Hello, World!"
result = s.rstrip("!")
print(result) # 输出: "Hello, World"
#splitlines() 方法常用于处理文本文件中的行数据，将其按行分割并进行后续处理。
s = "hello\nworld\n"
print(s.splitlines()) #['hello', 'world']
print(s.splitlines(keepends=True)) #['hello\n', 'world\n']
使用 .zfill() 方法在字符串的左侧填充了指定数量的零字符。填充的数量由指定的宽度决定，宽度包括原始字符串的长度和填充的零字符的数量。
如果原始字符串的长度已经大于或等于指定的宽度，则返回原始字符串本身，不会进行填充操作。
.zfill() 方法常用于需要将数字字符串格式化为指定宽度的场景，特别是在处理需要按位数对齐的数据时很有用，如日期、时间、序列号等。
a = "-42"
b = "hello"
print(a.zfill(6)) #-00042
print(b.zfill(7),b.zfill(3)) #00hello hello
8. Python布尔
布尔表示两值之一：True 或 False。
print(8 > 7)
print(7 ==8 )
print(7 > 8 )
a = 100
b = 200
if a < b :
print("a<b")
else:
print("a>b")
print(bool(10)) #True
print(bool(2.8)) #True
print(bool("hello")) #True
print(bool("")) #False
print(bool(0)) #False
print(bool([]))#False
print(bool({})) #False
print(bool(())) #False
实际上，除空值（例如 ()元组、[]列表、{}集合和字典、""、数字 0 和值 None）外，没有多少值会被评估为 False。当然，值 False 的计算结果为 False。
函数可返回布尔
.isinstance(object, classinfo)
- object：要检查的对象。
- classinfo：可以是一个类、类型元组或类型列表。
print(isinstance(a, int))
w = 3.25
print(isinstance(w,float)) #True
print(isinstance(w,(int,float,str))) #True
print(isinstance(w,(int,str))) #False
classinfo参数可以是单个类或类型，也可以是类型元组或类型列表。
当object是classinfo中任何一个类或类型的实例时，isinstance()函数会返回True，否则返回False。
9. Python 运算符
Python 在以下组中划分运算符：
假设变量a 为 10, b为 20
- 算术运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方 |
| // | 取整除 - 返回商的整数部分（向下取整） | 9//2 #4 -9//2 #-5 |
- 赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
- 比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 |
| <> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (a <> b) 返回 True。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。 | (a < b) 返回 True。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
- 逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。 | (a or b) 返回 10。 b or a 返回20 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
- 身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
※注： id() 函数用于获取对象内存地址。
- 成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
- 位运算符
二进制为何用八位来表示
八位（8bit）是一个字节，计算机中只要一个字节就可以存放ASCII编码，就是所有的数字、大小写字母和一些特殊字符（总共255个）。
所以在计算机中对用户来说有意义的单位就是字节，八位的二进制数最大值就是255，刚好表示255个ASCII字符。
汉字使用的是unicode编码的，unicode编码要用两个字节，所以要存放16位二进制数才能代表一个unicode字符。
另外还有UTF8编码占四个字节，等等。
变量 a 为 60，b 为 13
a = 0011 1100
b = 0000 1101
print( a & b ) #0000 1100 = 12
print( a | b ) #0011 1101 = 61
print( a ^ b ) #0011 0001 = 49
print( ~a ) #1100 0011 = -(64-3) = -61
print( ~b ) #1111 0010 = -(64-32-16-2) = -14 # 二进制取反，最高位1代表-号，用最高位依次减去低位
| 运算符 | 描述 | 实例 |
|---|---|---|
| --- | -------------------- | ---------------------------- |
| & | AND | 如果两个位均为 1，则将每个位设为 1。 |
| | | OR | 如果两位中的一位为 1，则将每个位设为 1。 |
| ^ | XOR | 如果两个位中只有一位为 1，则将每个位设为 1。 |
| ~ | NOT | 反转所有位。 |
| << | Zero fill left shift | 通过从右侧推入零来向左移动，推掉最左边的位。 |
| >> | Signed right shift | 通过从左侧推入最左边的位的副本向右移动，推掉最右边的位。 |
0000 1010 = 10
1111 0101 = -（64-32-16-4-1）=-11
10. Python集合（数组）
Python 集合（数组）
Python 编程语言中有四种集合数据类型：
- 列表（List）是一种有序和可更改的集合。允许重复的成员。
- 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
- 集合（Set）是一个无序和无索引的集合。没有重复的成员。
- 词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。
1.列表
列表是一个有序且可更改的集合。
lst = ["apple",1,3.14,"banana","cherry","orange"]
print(lst) # ['apple', 1, 3.14, 'banana', 'cherry', 'orange']
通过引用索引号来访问列表项
print(lst[1]) # 1
index查找对象索引位置
print(index(banana)) # 3
print(index(banana,4)) # 从索引位置4开始查找，报错 not in the list
负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目
print(lst[-1],lst[0]) # orange apple
通过指定范围的起点和终点来指定索引范围,右边不包括在范围内
print(lst[0:2]) # ['apple', 1]
print(lst[0:3:2]) 指定step
print(lst[-1:-4]) # []
print(lst[-4:-1]) # [3.14, 'banana', 'cherry']
当step为负数的时候往前计算
L = [1,3,4,5,6,7]
print(L[0:5:-2]) # [] 往前计算，0索引之前没有值，因而是空列表
print(L[5:3:-1]) # [7,6]
更改项目值
更改一个元素：
lst[1] = "hello"
print(lst) # ['apple', 'hello', 3.14, 'banana', 'cherry', 'orange']
更改多个元素：
lst[1:3] = [ 4,5]
print(lst) # ['apple',4,5, 'banana', 'cherry', 'orange']
遍历列表:遍历列表
for i in lst:
print(i)
检查项目是否存在,使用 in 关键字
if "apple" in lst:
print("apple in the lst")
else:
print("apple not in the lst")
使用 len() 方法，查看列表长度
print(len(lst)) # 6
列表的新增操作
使用 append() 方法,末尾添加一个元素
lst = ["apple",1,3.14,"banana","cherry","orange"]
lst.append("world")
print(lst) # ['apple', 'hello', 3.14, 'banana', 'cherry', 'orange', 'world']
lst.append([1,2])
print(lst) # ['apple', 'hello', 3.14, 'banana', 'cherry', 'orange', 'world',[1,2]]
使用 extend() 方法,末尾添加多个元素
lst = [1,2]
lst.extend([3,4])
print(lst) #[1,2,3,4]
使用 insert() 方法,在指定的索引处添加一个元素
lst = ["apple",1,3.14,"banana","cherry","orange"]
lst.insert(0,"head")
print(lst) # ['head', 'apple', 'hello', 3.14, 'banana', 'cherry', 'orange', 'world']
为指定切片赋予新值（在列表的任意位置一次至少添加一个元素）
L=[1,2,3]
L[1:1]=[4,5] #在index:1 和index:2之间添加元素
print(L) # [1,2,4,5,3]
L[len(L):]=[8,9] #在列表后追加，类似于append()
print(L) # [1,2,4,5,3,8,9]
删除项目(remove,pop,del,clear)
1.remove() 方法删除指定的元素
指定元素不存在，报错value error
lst.remove("world")
print(lst) # ['head', 'apple', 'hello', 3.14, 'banana', 'cherry', 'orange']
2.pop() 方法删除指定的索引
如果未指定索引，则删除最后一项
指定索引不存在，报错index error
lst.pop(0)
print(lst) # ['apple', 'hello', 3.14, 'banana', 'cherry', 'orange']
lst.pop()
print(lst) # ['apple', 'hello', 3.14, 'banana', 'cherry']
3.del
关键字删除指定的索引,del 关键字也能完整地删除列表
del lst[0]
print(lst) # ['hello', 3.14, 'banana', 'cherry']
del lst
print(lst) # NameError: name 'lst' is not defined
4.clear() 方法清空列表
lst.clear()
print(lst) # []
5.给指定的切片赋值一个空列表（一次至少删除一个元素）
L = ['hello', 3.14, 'banana', 'cherry']
L[1:2]=[]
print(L) #['hello','banana', 'cherry']
L[1:3]=[]
print(L) #['hello']
#清空列表
L[:]=[]
print(L) #[]
复制列表( =,copy,list() )
1.`list2 = list1` 来复制列表，因为：list2 将只是对 list1 的引用，
list1 中所做的更改也将自动在 list2 中进行。
lst = ['hello', 3.14, 'banana', 'cherry']
lst2 = lst
print(lst2) # ['hello', 3.14, 'banana', 'cherry']
# 2.使用内置的 List 方法 `copy()`
lst3 = lst.copy()
print(lst3) # ['hello', 3.14, 'banana', 'cherry']
# 3.使用内建的方法 `list()`
lst4 = list(lst)
print(lst4) # ['hello', 3.14, 'banana', 'cherry']
# list() 构造函数,使用 list() 构造函数创建一个新列表
lst4 = list((3.14, 'banana')) #请注意双括号
print(lst4) # [3.14, 'banana']
合并两个列表( + .append() extend() )
1.使用 + 运算符
del lst,lst2,lst3,lst4
lst = ['hello', 3.14, 'banana', 'cherry']
lst2 = [2,"world"]
print(lst + lst2) # ['hello', 3.14, 'banana', 'cherry', 2, 'world']
2.将 list2 中的所有项一个接一个地追加到 list1 中
for i in lst2:
lst.append(i)
print(lst) # ['hello', 3.14, 'banana', 'cherry', 2, 'world']
3.可以使用 extend() 方法，其目的是将一个列表中的元素添加到另一列表中
lst = ['hello', 3.14, 'banana', 'cherry']
lst2 = [2,"world"]
lst.extend(lst2)
print(lst) # ['hello', 3.14, 'banana', 'cherry', 2, 'world']
补充：
参数运算符+=会对列表本身进行修改
L1=L2=[1,2]
L1=L1+[3,4]
print(L1,L2) # [1,2,3,4][1,2]
L1=L2=[1,2]
L1+=[3,4]
print(L1,L2) # [1,2,3,4][1,2,3,4]
参数运算符*=会对列表本身进行修改
L1=L2=[1,2]
L1=L1*3
print(L1,L2) # [1,2,1,2,1,2][1,2]
L1=L2=[1,2]
L1*=3
print(L1,L2) # [1,2,1,2,1,2][1,2,1,2,1,2]
# 常用于列表的初始化
L=[0]*5
print(L) # [0,0,0,0,0]
列表比较
可以使用以下运算符进行列表之间的比较：
> >= < <= == !=
比较规则：首先比较两个列表中的第一个元素，如果相等则继续比较下一个元素，依次比较下去，直到两个列表中元素不相等时，比较结果就是两个列表的比较结果，后续元素将不进行比较
print([1,2,3,4,5]<[1,2,4,5]) #True
print([1,2,[4,3]] > [1,2,[3,4]]) #True
还可以用is对两个列表进行比较
==与is的区别：
==是相等性测试，比较的是value
is是同一性测试，比较的是内存中的id
列表方法
Python 有一组可以在列表上使用的内建方法。
| 方法 | 描述 |
|---|---|
| .append() | 在列表的末尾添加一个元素 |
| .clear() | 删除列表中的所有元素 |
| .copy() | 返回列表的副本 |
| .count() | 返回具有指定值的元素数量。 |
| .extend() | 将列表元素（或任何可迭代的元素）添加到当前列表的末尾 |
| .index() | 返回具有指定值的第一个元素的索引 |
| .insert() | 在指定位置添加元素 |
| .pop() | 利用索引位置，删除指定位置的元素；不指定，默认删除最后一个 |
| .remove() | 删除具有指定值的项目 |
| .reverse() | 颠倒列表的顺序，会改变原列表 |
| reversed() | 颠倒列表的顺序，不会改变列表 |
| .sort() | 对列表进行排序，会改变原列表，含有数字和字符串混合的不能排序，默认顺序排列 |
| sorted() | 对列表进行排序，不会改变列表，含有数字和字符串混合的不能排序 |
举例说明
lst = [1,4,2,7]
lst.sort()
print(lst) # [1, 2, 4, 7] #改变原列表顺序
lst.sort(reverse=True) # 指定参数倒序排列
print(lst) # [7, 2, 4, 1]
lst = [1,4,2,7]
lst.reverse()
print(lst) # [7, 2, 4, 1] #改变原列表顺序
lst = [1,2,4,3]
print(sorted(lst)) # [1, 2, 3, 4]
print(lst) # [1, 2, 4, 3] #不改变原列表顺序
print(sorted(lst,reverse=True) # 指定参数倒序排列 [4,3,2,1]
lst = [1,2,4,3]
print(reversed(lst)) # [3,4,2,1]
print(lst) # [1, 2, 4, 3] #不改变原列表顺序
# 含有数字和字符串混合的不能排序
lst = ["hello",3.14,"banana","cherry",2,1,"world"]
lst.sort()
print(lst) # TypeError: '<' not supported between instances of 'float' and 'str'
lst = ["hello","banana","cherry","world"]
lst.sort()
print(lst) #['banana', 'cherry', 'hello', 'world']
lst = ["徐州","上海","广州","world","apple"]
lst.sort()
print(lst) # ['apple', 'world', '上海', '广州', '徐州']
可以使用sys模块来查看列表占用的内存大小，并使用time模块来测量代码的执行时间
import sys,time
lst = [1,2,4,3,"上海",3.1415,(1,2,3)]
print( sys.getsizeof (lst)) # 120
start_time = time.time()
# 执行您的代码
end_time = time.time()
exe_time = end_time - start_time
print("代码执行时间：",exe_time) # 代码执行时间： 0.0 以秒为单位
多维列表的初始化
所谓的多维列表即列表中包含列表的情况
#[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
print([[0]*3]*4)
或者
print([0 for i in range(3)] for j in range(4))
1.2 Python 数组
什么时候使用数组？
列表比数组灵活得多。它们可以存储不同数据类型的元素，包括字符串。而且，列表比数组要快。
除非真的需要数组（与C代码接口可能需要数组模块），否则不要使用它们。
数组在Java，C / C ++，JavaScript等大多数编程语言中都很流行。但是，在Python中，它们并不常见。人们经常谈论Python数组时，他们谈论的是Python列表。在编程中，数组是相同类型的元素的集合。
数组和列表的区别：
1.列表(list)是Python内置的数据结构;在Python中使用数组的话，需要导入array或NumPy包
2.Python中的数组模块需要所有数组元素都具有相同类型,列表则可以是int,string,float
import array as arr
array_1 = arr.array("i",[1,2,3]) # i:int f:float
print(array_1,type(array_1))
其他操作参照list,不做详细了解
2. Python 元组
元组（Tuple）
元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。
为什么要设计元组这样的不可变类型呢？因为一旦创建了不可变类型的对象，对象内部的所有数据就不能被修改，这样就避免了由于修改数据导致的错误。
另外，对于不可变类型的对象，在多任务环境下同时操作对象时不需要加锁。
因此，在程序中尽可能使用不可变类型的对象
创建元组：
tuple1 = ("徐州","上海","广州","world","apple",1,2.14)
print(tuple1) # ('徐州', '上海', '广州', 'world', 'apple', 1, 2.14)
tuple1 = tuple(("徐州","上海","广州","world","apple",1,2.14)) # 请注意双括号
print(tuple1,type(tuple1)) # ('徐州', '上海', '广州', 'world', 'apple', 1, 2.14) <class 'tuple'>
访问元组项目:通过引用方括号内的索引号来访问元组项目
tuple1 = ("徐州","上海","广州","world","apple",1,2.14)
print(tuple1[1]) # 上海
print(tuple1[-2]) # 1
索引范围
可以通过指定范围的起点和终点来指定索引范围。
指定范围后，返回值将是带有指定项目的新元组。
tuple1 = ("徐州","上海","广州","world","apple",1,2.14)
print(tuple1[2:5]) # ('广州', 'world', 'apple')
print(tuple1[-4:-2]) # ('world', 'apple')
更改元组值
- 创建元组后，将无法更改其值。元组是不可变的，或者也称为恒定的。
- 但是有一种解决方法。可以将元组转换为列表，更改列表，然后将列表转换回元组。
tuple1 = ("徐州","上海","广州","world","apple",1,2.14)
y = list(tuple1)
print(y) # ['徐州', '上海', '广州', 'world', 'apple', 1, 2.14]
y[0] = "北京"
print(y) # ['北京', '上海', '广州', 'world', 'apple', 1, 2.14]
tuple1 = tuple(y)
print(tuple1) # ('北京', '上海', '广州', 'world', 'apple', 1, 2.14)
遍历元组,使用 for 循环遍历元组项目
for i in tuple1:
print(i)
检查项目是否存在,使用 in 关键字
if "新疆" in tuple1:
print("the word in the tuple1")
else:
print("not in the tuple1")
元组长度,使用 len() 方法
tuple1 = ("徐州","上海","广州","world","apple",1,2.14)
print(len(tuple1)) # 7
添加项目
元组一旦创建，您就无法向其添加项目。元组是不可改变的。
'''
thistuple = ("apple", "banana", "cherry")
thistuple[3] = "orange" # 会引发错误
print(thistuple)
# TypeError: 'tuple' object does not support item assignment
'''
创建有一个项目的元组
必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组
tuple1 = ("apple",)
print(type(tuple1)) # <class 'tuple'>
tuple1 = ("apple")
print(type(tuple1)) # <class 'str'>
删除项目
注释：无法删除元组中的项目,但可以通过转换成list删除。
元组是不可更改的，因此无法从中直接删除项目，但可以完全删除元组：
thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
print(y) # ['apple', 'banana', 'cherry']
y.remove("apple")
thistuple = tuple(y)
print(thistuple,type(thistuple)) # ('banana', 'cherry') <class 'tuple'>
del thistuple
# print(thistuple) # NameError: name 'thistuple' is not defined
合并两个元组,合并两个元组
tuple1 = ("apple", "banana", "cherry")
tuple2 = (1,)
print(tuple1 + tuple2) # ('apple', 'banana', 'cherry', 1)
元组方法
Python 提供两个可以在元组上使用的内建方法。
| 方法 | 描述 |
|---|---|
| count() | 返回元组中指定值出现的次数。 |
| index() | 在元组中搜索指定的值并返回它被找到的位置。 |
3. Python集合
集合（Set）
集合是无序和无索引的集合,不显示重复值。在 Python 中，集合用花括号编写；或者用set() 构造函数
set1 = {1,2,"hello","上海"}
print(set1,type(set1)) # {1, 2, '上海', 'hello'} <class 'set'>
set1 = {1,2,"hello","上海",1,2}
print(set1) # {1, 2, '上海', 'hello'}
set1 = set(("a", "b" , "c"))
print(set1,type(set1)) #{'a', 'b', 'c'} <class 'set'>
访问项目
无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。但是可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。
for i in set1:
print(i)
if "上海" in set1:
print("in the set")
print("上海" in set1) #True
更改项目
集合一旦创建，就无法更改项目，但是可以添加新项目。
添加项目 add()/update()
要将一个项添加到集合，请使用 add() 方法。
要向集合中添加多个项目，请使用 update() 方法。
set1 = {1,2,"hello","上海"}
set1.add("world")
print(set1) #{1, 2, '上海', 'hello', 'world'}
set1.update([10,"python"])
print(set1) #{1, 2, '上海', 'python', 10, 'hello', 'world'}
获取 Set 的长度 len()
要确定集合中有多少项，请使用 len() 方法。
set1 = {1, 2, '上海', 'python', 10, 'hello', 'world'}
print(len(set1)) # 7
删除项目
remove() 或 discard() 方法。
注释： 注释： 如果要删除的项目不存在，则 如果要删除的项目不存在，则remove() 将引发错误。如果要删除的项目不存在，则 discard() 不会引发错误。
set1 = {1,2,"hello","上海","python"}
set1.remove("上海")
print(set1) #{'python', 1, 2, 'hello'}
set1.discard(1)
print(set1) #{'python', 2, 'hello'}
pop() 方法随机删除项目
但此方法将删除最后一项。请记住，set 是无序的，因此不会知道被删除的是什么项目。pop() 方法的返回值是被删除的项目。
set1 = {1,2,"hello","上海","python"}
x = set1.pop()
print(x,set1) #python {1, 2, '上海', 'hello'}
注释： 集合是无序的，因此在使用 集合是无序的，因此在使用pop() 方法时，您不会知道删除的是哪个项目。
clear() 方法清空集合
set1.clear()
print(set1) # set()
del 彻底删除集合
del set1
print(set1) # NameError: name 'set1' is not defined
合并两个集合
可以使用 union() 方法返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中.不能直接用 + 拼接
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3) # {'b', 1, 2, 'a', 3, 'c'}
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
print(set1) # {1, 2, 3, 'a', 'c', 'b'}
# print(set2 + set1)
# #TypeError: unsupported operand type(s) for +: 'set' and 'set'
Set 方法
| 方法 | 描述 | ` |
|---|---|---|
| add() | 向集合添加元素。 | |
| clear() | 删除集合中的所有元素。 | |
| copy() | 返回集合的副本。 | |
| difference() | 返回包含两个或更多集合之间差异的集合。差集，符号- |
|
| discard() | 删除指定项目。 | |
| intersection() | 返回为两个其他集合的交集的集合。交集，符号& |
|
| isdisjoint() | 返回两个集合是否有交集。 | |
| issubset() | 返回另一个集合是否包含此集合。 | |
| issuperset() | 返回此集合是否包含另一个集合。 | |
| pop() | 从集合中删除一个元素。 | |
| remove() | 删除指定元素。 | |
| symmetric_difference() | 返回具有两组集合的对称差集的集合。堆成差集，符号^ |
|
| union() | 返回包含集合并集的集合。并集，符号` | |
| update() | 用此集合和其他集合的并集来更新集合。 |
4. Python字典
字典（Dictionary）
字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。
创建并打印字典
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
print(dict1) # {'name': 'sandy', 'age': 13, 'year': 1992}
dict2 = dict(name="sandy",age=13,year=1992)
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992}
# 请注意，键值不能加引号 dict("name"="sandy","age"=13,"year"=1992) X
# 请注意，使用了等号而不是冒号来赋值
访问项目
通过在方括号内引用其键名来访问字典的项目
- 通过在方括号内引用键名来访问字典的项目
get()的方法会给相同的结果
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
print(dict1) # {'name': 'sandy', 'age': 13, 'year': 1992}
print(dict1.get("name")) # sandy
print(dict1["name"]) # sandy
更改值
通过引用其键名来更改特定项的值
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
dict1["name"] = "Wendy"
print(dict1) # {'name': 'Wendy', 'age': 13, 'year': 1992}
遍历字典
使用 for 循环遍历字典。
循环遍历字典时，返回值是字典的键，但也有返回值的方法。
返回key
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
for i in dict1:
print(i)
'''
name
age
year
'''
返回value
for i in dict1.values():
print(i)
#或者
for i in dict1:
print(dict1[i])
'''
sandy
13
1992
'''
返回key-values
for x,y in dict1.items():
print(x,y)
'''
name sandy
age 13
year 1992
'''
检查键是否存在
使用 in 关键字
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
#检查key
if "name" in dict1:
print("name in the dict1")
#检查values
if "sandy" in dict1.values():
print("sandy in the dict1")
字典长度
确定字典有多少项目（键值对），使用 len() 方法
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
print(len(dict1)) # 3
添加项目
通过使用新的索引键并为其赋值，可以将项目添加到字典中
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
dict1["local"] = "shanghai"
print(dict1)
# {'name': 'sandy', 'age': 13, 'year': 1992, 'local': 'shanghai'}
删除项目
pop()删除具有指定键名的项popitem()方法删除最后插入的项目（在 3.7 之前的版本中，删除随机项目）del关键字删除具有指定键名的项目,也可以完全删除字典clear()关键字清空字典
dict1 = {
"name": "sandy",
"age": 13,
"year": 1992
}
dict1.pop("name")
print(dict1) # {'age': 13, 'year': 1992}
dict1 = dict(name="sandy",age=13,year=1992)
dict1.popitem()
print(dict1) # {'name': 'sandy', 'age': 13}
dict1 = dict(name="sandy",age=13,year=1992)
del dict1["name"]
print(dict1) # {'age': 13, 'year': 1992}
dict1 = dict(name="sandy",age=13,year=1992)
del dict1
print(dict1) # NameError: name 'dict1' is not defined. Did you mean: 'dict'?
dict1 = dict(name="sandy",age=13,year=1992)
dict1.clear()
print(dict1) # {}
复制字典
不能通过键入 dict2 = dict1 来复制字典，因为：dict2 只是对 dict1 的引用，而 dict1 中的更改也将自动在 dict2 中进行
- 使用
copy()方法来复制字典 - 使用
dict()方法创建字典的副本
dict1 = dict(name="sandy",age=13,year=1992)
dict2 = dict1
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992}
dict1["local"] = "shanghai"
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992, 'local': 'shanghai'}
dict1 = dict(name="sandy",age=13,year=1992)
dict2 = dict1.copy()
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992}
dict1["local"] = "shanghai"
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992}
dict1 = dict(name="sandy",age=13,year=1992)
dict2 = dict(dict1)
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992}
dict1["local"] = "shanghai"
print(dict2) # {'name': 'sandy', 'age': 13, 'year': 1992}
嵌套字典
词典也可以包含许多词典，这被称为嵌套词典。
方法一：
family = {
"sandy": {
"name": "sandy",
"age": 13,
"year": 1992
},
"wendy": {
"name": "wendy",
"age": 14,
"year": 1993
},
"saly": {
"name": "saly",
"age": 15,
"year": 1994
},
}
print(family)
输出结果：
{'sandy': {'name': 'sandy', 'age': 13, 'year': 1992}, 'wendy': {'name': 'wendy', 'age': 14, 'year': 1993}, 'saly': {'name': 'saly', 'age': 15, 'year': 1994}}
方法二：
sandy= {
"name": "sandy",
"age": 13,
"year": 1992
}
wendy= {
"name": "wendy",
"age": 14,
"year": 1993
}
saly= {
"name": "saly",
"age": 15,
"year": 1994
}
family={
"sandy": sandy,
"wendy": wendy,
"saly": saly
}
print(family)
输出结果：
{'sandy': {'name': 'sandy', 'age': 13, 'year': 1992}, 'wendy': {'name': 'wendy', 'age': 14, 'year': 1993}, 'saly': {'name': 'saly', 'age': 15, 'year': 1994}}
字典方法
| 方法 | 描述 |
|---|---|
clear() |
删除字典中的所有元素 |
copy() |
返回字典的副本 |
fromkeys() |
返回拥有指定键和值的字典 |
get() |
返回指定键的值 |
items() |
返回包含每个键值对的元组的列表 |
keys() |
返回包含字典键的列表 |
pop() |
删除拥有指定键的元素 |
popitem() |
删除最后插入的键值对 |
setdefault() |
返回指定键的值。如果该键不存在，则插入具有指定值的键。 |
update() |
使用指定的键值对字典进行更新 |
values() |
返回字典中所有值的列表 |
.update({"key": "value"})
dict1 = dict(name="sandy",age=13,year=1992)
dict1.update({"local": "shanghai"})
print(dict1) # {'name': 'sandy', 'age': 13, 'year': 1992, 'local': 'shanghai'}
dict1.update({"name": "wendy"})
print(dict1) # {'name': 'wendy', 'age': 13, 'year': 1992, 'local': 'shanghai'}
dict.fromkeys(keys,value)
value可选。所有键的值。默认值是 None。
fromkeys() 方法是在创建新字典并设置默认值时非常有用的工具。它可以用于各种情况，例如初始化字典、创建计数器或者设置默认配置等。
x = ("name","age","year")
y = 0
dict1 = dict.fromkeys(x,y)
print(dict1) # {'name': 0, 'age': 0, 'year': 0}
x = ("name","age","year")
dict1 = dict.fromkeys(x)
print(dict1) # {'name': None, 'age': None, 'year': None}
.setdefault(key, default_value)
key 是要获取或插入的键，default_value 是要为新插入的键设置的默认值。
1.获取字典中的值：
如果你想要获取字典中某个键对应的值，但不确定该键是否存在，可以使用 setdefault() 方法。如果键存在，则返回该键对应的值；如果键不存在，则返回设置的默认值。
dict1 = dict(name="sandy",age=13,year=1992)
print(dict1["local"]) #KeyError: 'local'
print(dict1.setdefault("local","Unknow")) # Unknow
2.初始化字典中的值
words_count = {}
txt = "a b c d e a b d d d"
words = txt.split()
for i in words:
words_count.setdefault(i,0)
words_count[i] += 1
print(words_count)
# {'a': 2, 'b': 2, 'c': 1, 'd': 4, 'e': 1}
Python条件
If ... Else
Python 支持来自数学的常用逻辑条件：
- 等于：a == b
- 不等于：a != b
- 小于：a < b
- 小于等于：a <= b
- 大于：a > b
- 大于等于：a >= b
If 语句：
a = input("输入a的值：\n")
b = input("输入b的值：\n")
if a < b:
print("a<b")
elif a == b:
print("a == b")
else:
print("a > b")
简写 If
只有一条语句要执行:
if a < b:print("a<b")
只有两条语句要执行:
print("a < b") if a < b else print(" a not < b")
使用多个 else 语句:
print("a<b") if a<b else print("a==b") if a ==b else print("a>b")
and和or
and、or 关键字是一个逻辑运算符，用于组合条件语句
a = 10
b = 12
c = 5
if a >b or c<b:
print("ok")
else:
print("not ok")
嵌套If
您可以在 if 语句中包含 if 语句，这称为嵌套 if 语句
x = 12
if x > 10:
print("Above ten,")
if x > 20:
print("and also above 20!")
else:
print("but not above 20.")
pass 语句
if 语句不能为空，但是如果您处于某种原因写了无内容的 if 语句，请使用 pass 语句来避免错误。
if b >a:
pass
Python While 循环
i = 1
dublesum = 0
singlesum = 0
while i <= 100:
if i % 2 == 0:
dublesum +=i
else:
singlesum +=i
i += 1
print(i,"偶数之和为：",dublesum,"。奇数之和为：",singlesum)
# 101 偶数之和为： 2550 。奇数之和为： 2500
注释：请记得递增 i，否则循环会永远继续。
break 语句
如果使用 break 语句，即使 while 条件为真，停止循环
在 i 等于 3 时退出循环：
i = 1
while i < 7:
if i == 3:
break
i += 1
print(i) # 3
密码输入超过3次错误退出
使用 else 语句，当条件不再成立时，我们可以运行一次代码块：
i = 1
while i <= 3:
a = input("输入密码：")
if a == "888":
print("密码正确！")
break
else:
print("密码错误！")
i += 1
else:
print("密码输入次数超过3次，已退出！")
continue 语句
使用 continue 语句，跳过当前迭代的剩余部分，并继续下一次迭代：
例子 1: 跳过奇数
num = 0
while num < 10:
num += 1
if num % 2 == 1:
continue
print(num) # 2 4 6 8 10
例子 2: 跳过特定值
num = [1,2,3,4,5,6,7]
for i in num:
if i == 3:
continue
print(i) # 1 2 4 5 6 7
例子 3: 跳过特定条件
num = 0
while num < 10:
num += 1
if num % 2 == 0:
continue
if num == 7:
break
print(num) # 1 3 5
Python For 循环
打印列表
fruits = ["apple", "banana", "cherry"]
for i in fruits:
print(i)
'''
apple
banana
cherry
'''
打印字典
student_scores = {'John': 85, 'Alice': 92, 'Bob': 78}
for x,y in student_scores.items():
print(x,"得分为：",y)
'''
John 得分为： 85
Alice 得分为： 92
Bob 得分为： 78
'''
循环遍历字符串
for i in "hello中国":
print(i)
# break 语句
# 通过使用 break 语句，我们可以在循环遍历所有项目之前停止循环
fruits = ["apple", "banana", "cherry"]
for f in fruits:
print(f)
if f == "banana":
break
'''
apple
banana
'''
continue 语句
fruits = ["apple", "banana", "cherry"]
for f in fruits:
if f == "banana":
break
print(f) # apple
fruits = ["apple", "banana", "cherry"]
for f in fruits:
if f == "banana":
continue
print(f)
'''
apple
cherry
'''
range() 函数
range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。
for i in range(3):
print(i)
'''
0
1
2
'''
注意：range(3) 不是 0 到 3 的值，而是值 0 到 2。
for i in range(2,9,2):
print(i)
else:
print("Finally finished!")
'''
2
4
6
8
Finally finished!
'''
嵌套循环
adj = ["red", "big"]
fruits = ["apple","cherry"]
for i in adj:
for j in fruits:
print(i,j)
else:
print("Finally finished!")
'''
red apple
red cherry
big apple
big cherry
Finally finished!
'''
案例 1: 打印九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print(j,"*",i,"=",i*j,end="\t")
print()
'''
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
'''
案例 2: 查找素数
for i in range(2,101):
for j in range(2,i):
if i % j == 0:
break
else:
print(i,end=" ")
# 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
案例 3: 图形输出
rows = 5
for i in range(1,rows+1):
for j in range(1,i+1):
print("*",end=" ")
print()
'''
*
* *
* * *
* * * *
* * * * *
'''
rows = 5
for i in range(1,rows+1):
# 打印空格
for j in range(1,rows-i+1):
print(" ",end="")
# 打印星号
for k in range(1,2*i):
print("*",end="")
# 换行
print()
for l in range(1,4):
print(" "*(rows-2),"*")
'''
*
***
*****
*******
*********
*
*
*
'''
Python 函数
def my_function():
print("hello from a function")
#调用函数
my_function()
# hello from a function
默认参数值
下面的例子展示如何使用默认参数值。
如果调用了不带参数的函数，则使用默认值
def my_function(fname = "Unknow"):
print(fname + " hello")
my_function("sandy") # sandy hello
my_function() # Unknow hello
以 List 传参
发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型
def my_function(food):
for i in food:
print(i)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
'''
apple
banana
cherry
'''
多参数
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function("andy","wendy","cidy") # The youngest child is andy
#如果不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Phoebe", "Jennifer", "Rory")
# The youngest child is Rory
例1.多参数求和
def add(a,b):
return a + b
print(add(1,2)) # 3
例2.任意参数求和
当函数需要接受任意数量的参数时，可以使用特殊的参数形式——*args。在函数定义中，*args表示接受任意数量的位置参数，它会将所有传递给函数的参数作为一个元组(tuple)来处理。
def sum_all(*args):
total = sum(args)
return total
k = sum_all(1,2,1,2,3,4,5)
print(k) # 18
递归
当一个函数在其定义中调用自身的过程称为递归。递归函数可以解决许多问题，尤其是涉及到递归结构的问题。
例子 1: 阶乘
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5)) # 120
例子 2: 斐波那契数列
又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”。指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……
def feibo(n):
if n <= 1:
return n
else:
return feibo(n -1) + feibo(n - 2)
print(feibo(7)) # 13
例子 3：打印自然数
def ziran(n):
if n > 0:
ziran(n-1)
print(n)
ziran(5)
# 1 2 3 4 5
Python Lambda
Lambda函数是一种匿名函数，也被称为“一次性函数”或“即时函数”。它是一种用于创建简单的、没有函数名的函数的快捷方式。Lambda函数通常用于函数式编程和简化代码的情况下。
语法格式：
$lambda arguments: expression$
例子 1: 计算两个数的和
add = lambda x,y: x + y
result = add(1,20)
print(result) # 21
例子 2: 对列表元素进行平方
lst = [1,2,3,4,5]
squared = list(map(lambda n: n**2,lst))
print(squared) # [1, 4, 9, 16, 25]
例子 3: 根据字符串长度进行排序
strings = ["hello", "world", "python", "code"]
sorted_strings = sorted(strings, key=lambda s: len(s))
print(sorted_strings)
# ['code', 'hello', 'world', 'python']
或者直接
strings = ["hello", "world", "python", "code"]
sorted_strings = sorted(strings,key=len)
print(sorted_strings)
# ['code', 'hello', 'world', 'python']
map()函数
map() 函数是 Python 内置的一个高阶函数，它接受一个函数和一个可迭代对象作为参数，并返回一个通过将函数应用于每个元素而生成的新的可迭代对象
map() 函数的基本语法如下：
$map(function, iterable)$
function 是一个函数，iterable 是一个可迭代对象（如列表、元组、集合等）。
map() 函数会对 iterable 中的每个元素应用 function 函数，并将结果作为一个新的可迭代对象返回。
示例: 大小写转换
words = ['Hello', 'World', 'Python']
print(list(map(str.lower,words)))
# ['hello', 'world', 'python']
示例: 长度计算
words = ['apple', 'banana', 'cherry']
lengths = map(len, words)
print(list(lengths))
# [5, 6, 6]
sorted()函数
Python 内置的一个高阶函数，用于对可迭代对象进行排序操作。它接受一个可迭代对象作为参数，并返回一个新的经过排序的列表。
sorted() 函数的基本语法如下：
$sorted(iterable, key=None, reverse=False)$
iterable 是一个可迭代对象（如列表、元组、集合等），key 是一个可选的函数用于指定排序的键，reverse 是一个可选的布尔值，用于指定是否进行反向排序，默认为 False。
示例 1: 对列表进行排序
numbers = [5, 2, 8, 1, 3]
sorted_numbers = sorted(numbers)
print(sorted_numbers)
# 输出: [1, 2, 3, 5, 8]
示例 2: 对字符串进行排序
words = ['banana', 'apple', 'cherry']
sorted_words = sorted(words)
print(sorted_words)
# 输出: ['apple', 'banana', 'cherry']
示例 3: 自定义排序规则
fruits = ['banana', 'apple', 'cherry']
sorted_fruits = sorted(fruits, key=len)
print(sorted_fruits)
# 输出: ['apple', 'cherry', 'banana']
Python 日期
import datetime
ticks = datetime.datetime.now()
print("现在时间是：",ticks) # 现在时间是： 2023-05-22 20:01:28.791376
print("年份：",ticks.year) # 2023
print("月份：",ticks.month) # 5
print("天：",ticks.day) # 22
print("时间：",ticks.time()) # 19:55:11.512536
print(ticks.strftime("%A")) # Monday
print(ticks.strftime("%B")) # May
print(ticks.strftime("%x")) # 05/22/23
print(ticks.strftime("%Y-%m-%d %H:%M:%S")) # 2023-05-22 20:00:20
日历（Calendar）模块
import calendar
cal = calendar.month(2023,5)
print("以下输出2023年5月的日历：")
print(cal)
'''
以下输出2023年5月的日历：
May 2023
Mo Tu We Th Fr Sa Su
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
'''
Python Try Except
try 块允许您测试代码块以查找错误。
except 块允许您处理错误。
finally 块允许您执行代码，无论 try 和 except 块的结果如何。
try-except用法：
try:
# 可能引发异常的代码块
# ...
except ExceptionType1:
# 处理 ExceptionType1 类型的异常
# ...
except ExceptionType2:
# 处理 ExceptionType2 类型的异常
# ...
except:
# 处理其他未指定的异常类型
# ...
finally:
print("The 'try except' is finished")
try:
dividend = 10
divisor = 0
result = dividend / divisor
print("结果：", result)
except ZeroDivisionError:
print("除以零错误")
except Exception as e:
print("发生了异常：", str(e))
例2：
try:
f = open("demofile.txt")
f.write("Lorum Ipsum")
except:
print("Something went wrong when writing to the file")
finally:
f.close()
try-except语句只捕获并处理try块中的代码所引发的异常。因此，仅在需要处理可能出现异常的代码时才使用try-except，避免滥用。
Python 文件处理
使用内建的 open() 函数。
open() 函数返回文件对象，此对象有一个 read() 方法用于读取文件的内容：
file = open("demofile.txt","r")
print(file.read())
只读取文件的一部分
默认情况下，read() 方法返回整个文本，但也可以指定要返回的字符数：
file = open("demofile.txt","r")
print(file.read(5)) # Hello
**通过重复调用 readline()，可以读取多行： **
f = open("demofile.txt", "r")
print(f.readline()) # Hello! Welcome to demofile.txt
print(f.readline()) # This file is for testing purposes.
print(f.readline()) # Good Luck!
通过循环遍历文件中的行，逐行读取整个文件：
f = open("demofile.txt", "r")
for i in f:
print(i)
关闭文件
f = open("demofile.txt","r")
print(f.readline())
f.close()
使用内建的 open() 函数。
open() 函数返回文件对象，此对象有一个 read() 方法用于读取文件的内容：
file = open("demofile.txt","r")
print(file.read())
只读取文件的一部分
默认情况下，read() 方法返回整个文本，但也可以指定要返回的字符数：
file = open("demofile.txt","r")
print(file.read(5)) Hello
通过重复调用 readline()，可以读取多行：
f = open("demofile.txt", "r")
print(f.readline()) Hello! Welcome to demofile.txt
print(f.readline()) This file is for testing purposes.
print(f.readline()) Good Luck!
通过循环遍历文件中的行，您可以逐行读取整个文件：
f = open("demofile.txt", "r")
for i in f:
print(i)
关闭文件
f = open("demofile.txt","r")
print(f.readline())
f.close()
例子：
filename = "word.txt"
print("按回车逐行显示文本内容：")
with open(filename, "r",encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
input()
print(line.rstrip(),end=" ")
写入已有文件
如需写入已有的文件，必须向 open() 函数添加参数：
- "a" - 追加 - 会追加到文件的末尾
- "w" - 写入 - 会覆盖任何已有的内容
f = open("demofile.txt","a")
f.write("Now the file has more content!")
f.close()
f = open("demofile.txt","r")
print(f.read())
Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck!
Now the file has more content!
f = open("demofile.txt","w")
f.write("write for the demofile")
f.close()
f = open("demofile.txt","r")
print(f.read())
# write for the demofile
注释："w" 方法会覆盖全部内容。
创建新文件
如需在 Python 中创建新文件，请使用 open() 方法，并使用以下参数之一：
- "x" - 创建 - 将创建一个文件，如果文件存在则返回错误
- "a" - 追加 - 如果指定的文件不存在，将创建一个文件
- "w" - 写入 - 如果指定的文件不存在，将创建一个文件
创建名为 "myfile.txt" 的文件：
f = open("myfile1.txt","x")
FileExistsError: [Errno 17] File exists: 'myfile1.txt'
如果不存在，则创建新文件：
f = open("myfile2.txt","w")
已经存在，不报错
删除文件
如需删除文件，必须导入 OS 模块，并运行其 os.remove() 函数：
import os
os.remove("demofile.txt")
检查文件是否存在
为避免出现错误，可能需要在尝试删除文件之前检查该文件是否存在：
import os
if os.path.exists("myfile1.txt"):
os.remove("myfile1.txt")
else:
print("Not exist!")
删除整个文件夹
使用 os.rmdir() 方法：
import os
os.rmdir("testdir")
OSError: [WinError 145] 目录不是空的。: 'testdir'
提示：只能删除空文件夹。
经典例子
1. 剪刀石头布
import random
while True:
a = int(input("请输入石头1、剪刀2，布3,退出4:\t"))
computer = random.randint(1, 3)
if a == 4:
print("退出游戏")
break
print("机器出的是：{}".format(computer), "你出的是：{}".format(a))
if ((a == 1 and computer == 2)
or (a == 2 and computer == 3)
or (a == 3 and computer == 1)):
print("恭喜你，获得了胜利")
elif a == computer:
print("你们平局了")
else:
print("不好意思，机器人获胜")
else:
print("比赛结束")
2.从列表中删除重复项
利用词典不能有重复的键
mylist = ["a", "b", "a", "c", "c"]
dit = list(dict.fromkeys(mylist))
print(dit) # ['a', 'b', 'c']
运维中的使用
主要从文本处理、系统监控、日志、FTP、邮件监控、微信监控等方面来介绍基础运维的相关知识
1.文本处理
通常用法：
k = open("hello.txt","r")
print(k.read())
k.close()
with-as-用法：
with 所求值的对象必须有__enter__()方法和__exit__()方法，紧跟 with 后面的语句被求值后，调用对象的__enter__()方法，该方法的返回值将被赋值给 as 后面的变量。
# 文本打印
with open("hello.txt","r") as f :
data_file = f.read()
print(data_file)
# 文本覆写
with open("hello.txt","w") as f:
date_file = f.write("overwrite the txt")
1.2.文件内存读取和替换
一次性全部读入内存
对文件的内容做出任意修改，再保存至磁盘
import os
with open('hello.txt',"r") as read_f,open("hello.txt.swap","w") as write_f:
data = read_f.read()
data = data.replace("txt","line")
write_f.write(data)
os.remove("hello.txt")
os.rename("hello.txt.swap","hello.txt")
with open("hello.txt","r") as read_f:
print(read_f.read())
'''
overwrite the line
overwrite the line2
overwrite the line3
'''
迭代方式将内容逐行读入内存
使用文件的可迭代方式将文件的内容逐行读入内存，再逐行写入新文件，最后用新文件覆盖源文件
import os
with open('hello.txt',"r") as read_f,open("hello.txt.tmp","w") as write_f:
for line in read_f:
line = line.replace("overwrite","This is")
write_f.write(line)
os.remove("hello.txt")
os.rename("hello.txt.tmp","hello.txt")
with open("hello.txt","r") as read_f:
print(read_f.read())
'''
This is the line
This is the line2
This is the line3
'''
文本逐行打印输出
with open("hello.txt","r") as read_f:
lines = read_f.readlines()
print(lines) # ['This is the line\n', 'This is the line2\n', 'This is the line3']
num = 0
for i in lines:
print("输出：{}".format(i.strip())) # 去除开头和结尾的空白
num = num + 1
print("总计行数：",num)
'''
输出：This is the line
输出：This is the line2
输出：This is the line3
总计行数： 3
'''
2.系统信息监控
CPU 的使用率、内存的占用情况、网络、进程
获取CPU信息
import psutil
print(psutil.cpu_count())
# 8 CPU 逻辑数量
print(psutil.cpu_count(logical=True))
# 8 CPU 逻辑数量
print(psutil.cpu_count(logical=False))
# 4 # CPU 物理数量
print(psutil.cpu_percent())
# 11.7 CUP占比
print(psutil.cpu_percent(interval=1))
# 使用interval参数指定采样的时间间隔（单位为秒）
print(psutil.cpu_percent(percpu=True))
# [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] 每个CPU的占比
监控磁盘信息
import psutil
print(psutil.disk_partitions())
print(psutil.disk_usage("/"))
print("磁盘总空间：{:.2f} GB".format(psutil.disk_usage("/").total/1024/1024/1024))
print("磁盘已用空间：{:.2f} GB".format(psutil.disk_usage("/").used/1024/1024/1024))
print("磁盘利用率：{:.2f} %".format(psutil.disk_usage("/").percent))
'''
[sdiskpart(device='C:\\', mountpoint='C:\\', fstype='NTFS', opts='rw,fixed', maxfile=255, maxpath=260)]
sdiskusage(total=254721126400, used=191546204160, free=63174922240, percent=75.2)
磁盘总空间：237.23 GB
磁盘已用空间：178.39 GB
磁盘利用率：75.20 %
'''
I/O读取信息
print(psutil.disk_io_counters())
print(" 读取次数：{}".format(psutil.disk_io_counters().read_count),"\n",
"读取字节数：{:.2f} GB".format(psutil.disk_io_counters().read_bytes/(1024**3)),"\n",
"读取时间：{:.2f} s".format(psutil.disk_io_counters().read_time/1000)
)
sdiskio(read_count=1190930, write_count=1522847, read_bytes=62645898752, write_bytes=59449583616, read_time=541, write_time=705)
读取次数：1202846
读取字节数：58.63 GB
读取时间：0.54 s
# read_time 表示磁盘读取操作的时间（以毫秒为单位
查看指定磁盘的计数器信息
# 获取磁盘I/O计数器信息
import psutil
disk_io = psutil.disk_io_counters(perdisk=True)
# 查看磁盘分区信息
disk_partitions = psutil.disk_partitions()
for partition in disk_partitions:
print(partition.device)
# 使用正确的磁盘名称获取计数器信息
disk_name = "C:\\"
if disk_name in disk_io:
disk_io_c = disk_io[disk_name]
print(f"读取次数：{disk_io_c.read_count}")
else:
print(f"无法找到磁盘{disk_name}")
监控内存信息
import psutil
print(psutil.virtual_memory())
print("总内存：{:.2f} GB".format(psutil.virtual_memory().total/1024/1024/1024))
print("可用内存: {:.2f} GB".format(psutil.virtual_memory().available / 1024/1024/1024))
print("内存使用率：{} %".format(psutil.virtual_memory().percent))
'''
svmem(total=16918601728, available=5838901248, percent=65.5, used=11079700480, free=5838901248)
总内存：15.76 GB
可用内存: 5.47 GB
内存使用率：65.3 %
'''
监控网络信息
获取网络读写字节／包的个数
import psutil
print(psutil.net_io_counters())
'''
snetio(bytes_sent=1545548468, bytes_recv=4125362269, packets_sent=3982060,
packets_recv=4886215, errin=0, errout=0, dropin=2420, dropout=0)
'''
获取网络接口信息
print(psutil.net_if_addrs())
'''
{'以太网 2': [snicaddr(family=<AddressFamily.AF_LINK: -1>, address='02-50-41-00-00-01', netmask=None, broadcast=None, ptp=None), snicaddr(family=<AddressFamily.AF_INET: 2>, address='9.79.70.177', netmask='255.255.255.255', broadcast=None, ptp=None)],
'vEthernet (Default Switch)': [snicaddr(family=<AddressFamily.AF_LINK: -1>, address='00-15-5D-A9-E4-C5', netmask=None, broadcast=None, ptp=None), snicaddr(family=<AddressFamily.AF_INET: 2>, address='172.17.160.1', netmask='255.255.240.0', broadcast=None, ptp=None), snicaddr(family=<AddressFamily.AF_INET6: 23>, address='fe80::ae29:37de:ea09:337a', netmask=None, broadcast=None, ptp=None)],
'vEthernet (NewVM_network)': [snicaddr(family=<AddressFamily.AF_LINK: -1>, address='00-15-5D-00-01-04', netmask=None, broadcast=None, ptp=None), snicaddr(family=<AddressFamily.AF_INET: 2>, address='192.168.137.1', netmask='255.255.255.0', broadcast=None, ptp=None), snicaddr(family=<AddressFamily.AF_INET6: 23>, address='fe80::c9c2:8c2d:5cbb:bacc', netmask=None, broadcast=None, ptp=None)],
'''
获取网络接口状态
print(psutil.net_if_stats())
'''
{'蓝牙网络连接': snicstats(isup=False, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=3, mtu=1500, flags=''),
'以太网': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=1000, mtu=1500, flags=''),
'以太网 2': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=2000, mtu=1354, flags=''),
'vEthernet (Default Switch)': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=4294, mtu=1500, flags=''),
'vEthernet (NewVM_network)': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=4294, mtu=1500, flags=''),
'Loopback Pseudo-Interface 1': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=1073, mtu=1500, flags=''),
'WLAN': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=287, mtu=1500, flags=''),
'本地连接* 9': snicstats(isup=False, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=0, mtu=1500, flags=''),
'本地连接* 10': snicstats(isup=False, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=0, mtu=1500, flags='')}
'''
获取当前网络连接信息
print(psutil.net_connections())
'''
[sconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_DGRAM: 2>, laddr=addr(ip='0.0.0.0', port=57838), raddr=(), status='NONE', pid=5284), sconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=52208), raddr=addr(ip='127.0.0.1', port=52209), status='ESTABLISHED', pid=27000), sconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=53587), raddr=addr(ip='127.0.0.1', port=49152), status='ESTABLISHED', pid=12276), sconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_DGRAM: 2>, laddr=addr(ip='0.0.0.0', port=56488), raddr=(), status='NONE', pid=4), sconn(fd=-1,
'''
获取进程信息
import psutil
# 获取所有进程的PID
'''
pid = psutil.pids()
print(pid)
'''
# 查找具体应用程序的相关信息
for process in psutil.process_iter(attrs=["pid","name","username"]):
if process.info["name"].startswith("wolai"):
pid = process.info["pid"]
print(pid,end=" ")
print(psutil.Process(pid).cpu_times(),end=" ") # 获取 CPU 占用
print("进程的内存占比：{:.2f} %".format(psutil.Process(pid).memory_percent())) # #获取内存占用
'''
6408 pcputimes(user=10.90625, system=8.890625, children_user=0.0, children_system=0.0) 进程的内存占比：0.11 %
10492 pcputimes(user=1.34375, system=1.5, children_user=0.0, children_system=0.0) 进程的内存占比：0.05 %
13244 pcputimes(user=1677.859375, system=99.609375, children_user=0.0, children_system=0.0) 进程的内存占比：1.95 %
17288 pcputimes(user=435.34375, system=894.9375, children_user=0.0, children_system=0.0) 进程的内存占比：0.41 %
19908 pcputimes(user=226.890625, system=47.25, children_user=0.0, children_system=0.0) 进程的内存占比：0.30 %
32912 pcputimes(user=0.21875, system=0.171875, children_user=0.0, children_system=0.0) 进程的内存占比：0.05 %
===
cpu_times() 方法返回的命名元组中，包含以下字段：
user：进程在用户态的CPU时间
system：进程在系统态的CPU时间
idle：进程的空闲CPU时间
'''
print("进程的内存占比：{:.2f} %".format(psutil.Process(6408).memory_percent()))
# 进程的内存占比：0.11 %
文件系统监控
运维工作离不开文件系统的监控，如某个目录被删除，或者某个文件被修改、移动、删除
时需要执行一定的操作或发出报警。
from watchdog.observers import Observer
from watchdog.events import *
import time
class FileEventHandler(FileSystemEventHandler):
def __init__(self):
FileSystemEventHandler.__init__(self)
def on_moved(self, event):
now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if event.is_directory:
print(f"{ now } 文件夹由 { event.src_path } 移动至{ event.dest_path }")
else:
print(f"{ now } 文件由 { event.src_path } 移动至 { event.dest_path }")
def on_created(self, event):
now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if event.is_directory:
print(f"{ now } 文件夹 { event.src_path } 创建")
else:
print(f"{ now } 文件 { event.src_path } 创建")
def on_deleted(self, event):
now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if event.is_directory:
print(f"{ now } 文件夹 { event.src_path } 删除")
else:
print(f"{ now } 文件 { event.src_path } 删除")
def on_modified(self, event):
now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if event.is_directory:
print(f"{ now } 文件夹 { event.src_path } 修改")
else:
print(f"{ now } 文件 { event.src_path } 修改")
if __name__ == "__main__":
observer = Observer()
path = r"C:\Users\KeXueSun\Downloads" # r 前缀表示该字符串是一个原始字符串（raw string），它可以包含特殊字符而无需进行转义。
event_handler = FileEventHandler()
observer.schedule(event_handler, path, True)#True 表示递归子目录
print(f"监控目录 {path}")
observer.start()
observer.join()
实时显示：
3.执行外部命令 subprocess
subprocess使用的方法，都是对subprocess.Popen的封装
subprocess.run()
#导入subprocess module
import subprocess
#subprocess.run()
sr=subprocess.run("df -h ",shell=True)
print(sr)
print("***************分隔线***************")
sr2=subprocess.run("df -h | grep /dev/sda1",shell=True)
print(sr2)
'''
[root@master ~]# /usr/bin/python /root/pytest/sub.py
文件系统 容量 已用 可用 已用% 挂载点
devtmpfs 876M 0 876M 0% /dev
tmpfs 887M 0 887M 0% /dev/shm
tmpfs 887M 13M 875M 2% /run
tmpfs 887M 0 887M 0% /sys/fs/cgroup
/dev/mapper/centos_master-root 50G 8.9G 42G 18% /
/dev/sda1 1014M 241M 774M 24% /boot
/dev/mapper/centos_master-home 74G 972M 74G 2% /home
tmpfs 178M 0 178M 0% /run/user/0
CompletedProcess(args='df -h ', returncode=0)
***************分隔线***************
/dev/sda1 1014M 241M 774M 24% /boot
CompletedProcess(args='df -h | grep /dev/sda1', returncode=0)
'''
subprocess.call()
执行命令，返回命令的结果和执行状态，0或者非0
print("***************分隔线***************")
res=subprocess.call("ls -l pytest",shell=True)
print(res)
'''
总用量 8
-rw-r--r-- 1 root root 1203 6月 16 16:18 sub.py
-rw-r--r-- 1 root root 741 6月 14 14:42 test.sh
0
'''
subprocess.check_call()
执行命令，返回结果和状态，正常为0 ，执行错误则抛出异常
print("***************分隔线***************")
check_call=subprocess.check_call("ls -l pytest",shell=True)
print(check_call)
print("***************分隔线***************")
check_call2=subprocess.check_call("lm -l pytest",shell=True)
print(check_call2)
'''
***************分隔线***************
总用量 8
-rw-r--r-- 1 root root 1753 6月 16 16:21 sub.py
-rw-r--r-- 1 root root 741 6月 14 14:42 test.sh
0
***************分隔线***************
/bin/sh: lm: 未找到命令
Traceback (most recent call last):
File "/root/pytest/sub.py", line 43, in <module>
check_call2=subprocess.check_call("lm -l pytest",shell=True)
File "/usr/lib64/python3.6/subprocess.py", line 311, in check_call
raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'lm -l pytest' returned non-zero exit status 127.
'''
subprocess.getstatusoutput()
接受字符串形式的命令，返回 一个元组形式的结果，第一个元素是命令执行状态，第二个为执行结果
print("***************分隔线***************")
print(subprocess.getstatusoutput("pwd"))
'''
(0, '/root')
'''
subprocess.getoutput()
print(subprocess.getoutput("pwd")) #/root
4.logging日志模块
import logging
logging.debug("debug MSG")
logging.info("info MSG")
logging.warning("warning MSG")
logging.error("error MSG")
logging.critical("critical MSG")
'''
WARNING:root:warning MSG
ERROR:root:error MSG
CRITICAL:root:critical MSG
'''
日志级别:日志器名称:日志内容
之所以会这样输出，是因为logging模块提供的日志记录函数所使用的日志器设置的日志格式默认是BASIC_FORMAT，其值为：
"%(levelname)s:%(name)s:%(message)s"
默认情况下，Python 的 logging 模块将日志打印到标准输出中，而且只显示大于等于WARNING 级别的日志，这说明默认的日志级别设置为 WARNING（日志级别等级 CRITICAL>WARNING > INFO > DEBUG ）。默认的日志格式：日志级别为 Logger，名称为用户输出消息。
各日志级别代表的含义如下。
- DEBUG：调试时的信息打印。
- INFO：正常的日志信息记录。
- WARNING：发生了警告信息，但程序仍能正常工作。
- ERROR：发生了错误，部分功能已不正常。
- CRITICAL：发生严重错误，程序可能已崩溃。
指定输出文件地址
import logging,subprocess
logging.basicConfig(filename="./logging.log")
logging.debug("debug MSG")
logging.info("info MSG")
logging.warning("warning MSG")
logging.error("error MSG")
logging.critical("critical MSG")
print("***************分隔线***************")
print(subprocess.run("ls -l logging.log", shell=True))
'''
# /usr/bin/python /root/pytest/sub.py
***************分隔线***************
-rw-r--r-- 1 root root 292 6月 16 16:48 logging.log
CompletedProcess(args='ls -l logging.log', returncode=0)
执行以上代码后发现，在当前目录多了一个文件 logging.log，文件内容与第一个例子的输出是一致的。
多次执行 sub.py 发现 log 文件的内容变多了，说明默认的写 log 文件的方式是追加。
'''
配置日志器的日志级别
print("***************分隔线***************")
logging.basicConfig(level=logging.INFO)
logging.debug("debug MSG")
logging.info("info MSG")
logging.warning("warning MSG")
logging.error("error MSG")
logging.critical("critical MSG")
'''
INFO:root:info MSG
WARNING:root:warning MSG
ERROR:root:error MSG
CRITICAL:root:critical MSG
'''
配置下日志输出目标文件和日志格式
print("***************分隔线***************")
logging.basicConfig(level=logging.DEBUG,format="%(asctime)s - %(levelname)s - %(message)s")
logging.debug("debug MSG")
logging.info("info MSG")
logging.warning("warning MSG")
logging.error("error MSG")
logging.critical("critical MSG")
'''
print("***************分隔线***************")
2023-06-16 17:03:15,834 - DEBUG - debug MSG
2023-06-16 17:03:15,834 - INFO - info MSG
2023-06-16 17:03:15,834 - WARNING - warning MSG
2023-06-16 17:03:15,834 - ERROR - error MSG
2023-06-16 17:03:15,834 - CRITICAL - critical MSG
设置日期/时间格式
print("***************分隔线***************")
logging.basicConfig(level=logging.DEBUG,format="%(asctime)s - %(levelname)s - %(message)s",datefmt="%Y/%m/%d %H:%M:%S")
logging.debug("debug MSG")
logging.info("info MSG")
logging.warning("warning MSG")
logging.error("error MSG")
logging.critical("critical MSG")
'''
***************分隔线***************
2023/06/16 17:05:51 - DEBUG - debug MSG
2023/06/16 17:05:51 - INFO - info MSG
2023/06/16 17:05:51 - WARNING - warning MSG
2023/06/16 17:05:51 - ERROR - error MSG
2023/06/16 17:05:51 - CRITICAL - critical MSG
'''
综合配置
import logging
logging.basicConfig(level=logging.INFO,
format="%(asctime)s %(levelname)s %(message)s",
datefmt=" %Y-%m-%d %H:%M:%S",
filename="/var/log/logging.log",
filemode="w"
)
logging.debug("This is the debug message")
logging.info("info MSG")
logging.warning("warning MSG")
logging.error("error MSG")
logging.critical("critical MSG")
'''
[root@master ~]# /usr/bin/python /root/pytest/sub.py
[root@master ~]# cat /var/log/logging.log
2023-06-16 17:19:51 INFO info MSG
2023-06-16 17:19:51 WARNING warning MSG
2023-06-16 17:19:51 ERROR error MSG
2023-06-16 17:19:51 CRITICAL critical MSG
'''
