Python从入门到自动化运维

IPO编程方式、print、input函数

print() – 输出信息到屏幕

print('Hello World')name = "Lei"
age = 20
print("名字：", name, "年龄：", age)

常用参数

参数名	说明
sep	指定多个参数之间的分隔符，默认是空格 " "
end	输出结束后的字符，默认是换行符 "\n"
file	输出目标，默认是终端，可以写入文件
flush	是否立刻输出缓存，默认是 False

print("apple", "banana", "cherry", sep=", ")  # 输出用逗号分隔
# 输出：apple, banana, cherryprint("Hello", end="")  # 不换行
print("World")          # 紧接着输出
# 输出：HelloWorld

输出格式化字符串（推荐）

name = "Bob"
age = 25# 方法1：f-string（推荐）
print(f"我的名字是{name}，我今年{age}岁。")
print("我的名字是{name}，我今年{age}岁。")# 方法2：.format()
print("我的名字是{}，我今年{}岁。".format(name, age))

input() – 读取用户的输入

name = input("请输入你的名字：")
print("你好，" + name)

input() 会暂停程序，等用户输入内容并按回车
输入内容是字符串（类型为 str）

如果你需要用户输入一个数字，比如整数或浮点数，需要手动转换：

age = int(input("请输入你的年龄："))  # 转换为整数
height = float(input("请输入你的身高（米）："))  # 转换为浮点数

name = input("请输入你的名字：")
age = int(input("请输入你的年龄："))
print(f"{name}，你明年就 {age + 1} 岁了！")

基本数据类型

int、float、bool、str

# 整数（int）
a = 10# 浮点数（float）
pi = 3.14# 布尔值（bool）
is_ok = True     # 或 False# 字符串（str） 字符串可以用单引号或双引号包围。
name = "Alice"
sentence = 'Hello, world!'

常用 str 操作方法

方法	作用	示例
lower()	转换为小写	'Hello'.lower() → 'hello'
upper()	转换为大写	'Hello'.upper() → 'HELLO'
strip()	去除前后空白字符	' hi '.strip() → 'hi'
replace(old, new)	替换字符串内容	'a-b-c'.replace('-', '+') → 'a+b+c'
split(sep)	拆分为列表	'a,b,c'.split(',') → ['a', 'b', 'c']
join(iterable)	用当前字符串连接序列	','.join(['a', 'b']) → 'a,b'
find(sub)	查找子串，返回索引	'abc'.find('b') → 1
count(sub)	子串出现次数	'banana'.count('a') → 3
startswith(prefix)	是否以 prefix 开头	'hello'.startswith('he') → True
endswith(suffix)	是否以 suffix 结尾	'hello'.endswith('lo') → True
isdigit()	是否是数字字符	'123'.isdigit() → True
isalpha()	是否是字母	'abc'.isalpha() → True
isalnum()	是否是字母或数字	'abc123'.isalnum() → True
format()	格式化字符串	'Name: {}'.format('Tom') → 'Name: Tom'
zfill(width)	左侧补零	'42'.zfill(5) → '00042'

s = "  Hello, World!  "print(s.strip())            # 去空格 → "Hello, World!"
print(s.lower())            # 小写 → "  hello, world!  "
print(s.upper())            # 大写 → "  HELLO, WORLD!  "
print(s.replace(",", "."))  # 替换 → "  Hello. World!  "
print(s.split(","))         # 拆分 → ['  Hello', ' World!  ']
print(".".join(["a", "b"])) # 拼接 → "a.b"
print(s.find("World"))      # 查找 → 9
print(s.count("l"))         # 统计 → 3
print("12345".isdigit())    # True
print("abc123".isalnum())   # True
print("Hello".startswith("He"))  # True

str1='[e-mail]'
list1=str1.split('@')
print('邮箱名是：',list1[0],'邮箱服务器：',list1[1])  # 邮箱名是： leilei 邮箱服务器： 163.com

🧠 提示：面试中优先记住这些！

strip() / lower() / replace() → 清洗字符串常用
split() / join() → 拆分与合并
find() / count() → 查找统计
startswith() / endswith() → 过滤文本
isdigit() / isalpha() / isalnum() → 验证输入格式
format() / f-string → 字符串格式化输出

格式化字符串的三种方式

#（1）使用占位符进行格式化
name='马冬梅'
age=19
score=98.5
print('姓名：%s,年龄：%d,成绩：%f' %(name, age, score))     # 姓名：马冬梅,年龄：19,成绩：98.500000
print('姓名：%s,年龄：%d,成绩：%.1f' %(name, age, score))   # 姓名：马冬梅,年龄：19,成绩：98.5#（2）f-string
print(f'姓名：{name},年龄：{age},成绩：{score}')    # 姓名：马冬梅,年龄：19,成绩：98.5#（3）使用字符串的format方法
print('姓名：{0},年龄：{1},成绩：{2}'.format(name,age,score))
print('姓名：{2},年龄：{0},成绩：{1}'.format(age,score,name))

数据验证方法

# isdigit() 十进制的阿拉伯数字
print('123'.isdigit())      # True
print('一二三'.isdigit())    # False
print('0b101'.isdigit())    # False
print('-'*50)# 所有字符都是数字
print('123'.isnumeric())    # True
print('一二三'.isnumeric())  # True
print('0b10'.isnumeric())   # False
print('Ⅱ'.isnumeric())      # 罗马数字 True
print('壹贰叁'.isnumeric())  # True
print('-'*50)# 所有字符都是字母（包含中文字符）
print('hello你好'.isalpha())   # True
print('hello你好123'.isalpha())   # False

字符串拼接

s1='hello'
s2='world'#第一种方式：使用加号'+'拼接
print(s1+s2)   # helloworld#第二种方式：使用字符串的join()方法
print(''.join([s1,s2]))  # helloworld  使用空字符串进行拼接
print('*'.join(['pyhon','java','linux','php']))  # pyhon*java*linux*php
print('你好'.join(['pyhon','java','linux','php'])) # pyhon你好java你好linux你好php#第三种方式：直接拼接
print('hello''world''你好')  # helloworld你好#第四种方式：使用格式化字符串
print('%s%s' %(s1,s2))   # helloworld
print(f'{s1}{s2}')   # helloworld
print('{0}{1}'.format(s1,s2))  # helloworld

字符串去重

s='helloworldhelloworldhelloworldhelloworldhelloworld'# 第一种方式：通过遍历字符及not in
new_s=''
for it in s:if it not in new_s:new_s+=it
print(new_s)     # helowrd# 第二种方式：使用索引+ not in
new_s2=''
for i in range(len(s)):if s[i] not in new_s2:new_s2+=s[i]
print(new_s2)   #  helowrd# 第三种方式：通过集合去重+列表排序
new_s3=set(s)
lst=list(new_s3)
lst.sort(key=s.index)
print(''.join(lst)) #  helowrd

lst.sort(key=s.index) 排序

这一行是关键！
s.index(x) 会返回字符 x 在原字符串中第一次出现的索引位置。
key=s.index 让 sort 以字符在原字符串的首次出现位置为排序依据。

key 不是你定义的变量，而是 sort() 方法的一个参数名字，它用来指定排序时的比较依据（规则）。

key 参数的作用

1. list.sort() 和 sorted() 都有一个可选的参数 key。
2. 它要求你传入一个函数（或可调用对象），这个函数接收一个元素，返回一个用来比较大小的值。
3. 排序时，Python 会对列表里的每个元素调用这个函数，把返回值当作排序的依据。

数据类型转换函数

隐式转换：Python主动完成
显示装换：使用下列函数：int()、float()、str()…等完成

目标类型	函数	示例
整数	int(x)	int("123") → 123
浮点数	float(x)	float("3.14") → 3.14
字符串	str(x)	str(123) → "123"
布尔值	bool(x)	bool(0) → False
列表	list(x)	list("abc") → ['a', 'b', 'c']
元组	tuple(x)	tuple([1,2]) → (1, 2)
集合	set(x)	set([1,1,2]) → {1, 2}
字典	dict(x)	dict([("a", 1), ("b", 2)])

str ↔ int / float（字符串 和 数字 之间转换）

# 字符串转整数
a = int("42")        # 42# 字符串转浮点数
b = float("3.14")    # 3.14# 数字转字符串
s = str(100)         # "100"

容器类型

列表（list）✅ 可变、可重复、有序

fruits = ["apple", "banana", "orange"]
fruits[0]        # 访问第一个元素 -> "apple"
fruits.append("grape")  # 添加元素

元组（tuple）✅ 不可变、可重复、有序

元组是Python中不可变数据类型，它没有相关的增删改的一系列操作，它只能使用索引去获取元素和使用for循环去遍历元素。

所谓的"不可变“”意思是：

一旦创建，变量的“整体结构”就不能被修改。

也就是说：

1. 元组本身的长度不能变（不能添加/删除元素）
2. 元组中某个位置的元素不能被替换

❓但很多人疑问：如果元组里放的是“可变对象”，还能改吗？
✅ 答案是：可以修改可变对象的内容，但不能修改元组的结构！
来看看例子：

t = ([1, 2], 3)t[0].append(100)   # ✅ 这是合法的！
print(t)           # 输出：([1, 2, 100], 3)t[0] = [9, 9]      # ❌ 报错！不能替换整个元素

解释：

1. 元组t包含两个元素：一个列表[1, 2]和一个整数3
2. 你不能改变 t[0] 这个位置放的对象是谁（这属于元组结构），
3. 但你可以修改 t[0] 这个列表内部的内容（因为列表是可变的）

point = (10, 20)
point[0]         # -> 10
# point[0] = 30  # ❌ 报错：tuple是不可变的,报错：'tuple' object does not support item assignment

元组的创建方式

1. 使用（）去定义元组，元素之间使用英文逗号分隔
   元组名=（element1,element2,element3,…elementN）
2. 使用（）内置函数 tuple() 创建元组
   元组名= tuple(序列)

删除元祖：del()

元组中只有一个元素时，逗号也不能省略

t=(10)
print(t,type(t))  #t输出的是一个int类型y=(10,)
print(y,type(y)) #y输出的才是元组类型

删除元组

del 元组名

元组元素的访问与遍历

#切片操作
t2=t[0:3:2]
print(t2)  # ('python', 'Linux')

# 元组的遍历
for i in t:print(i)

# for+range()+len()
for i in range(len(t)):print(i,t[i])打印结果
0 python
1 java
2 Linux
3 hello
4 word

# enumerate
for index, item in enumerate(t):print(index,">>>",item)打印结果
0 >>> python
1 >>> java
2 >>> Linux
3 >>> hello
4 >>> word

修改序号

集合（set）✅ 可变、不重复、无序

colors = {"red", "green", "blue"}
colors.add("yellow")

自动去重。
不能通过下标访问元素（因为无序）。

集合的创建

# {}直接创建集合
s={10,20,30,40}
print(s)# 集合只能存储不可变数据类型
#s={[10,20],[30,40]}
#print(s) # TypeError: unhashable type: 'list'# 使用set()创建集合
s=set() # 创建了一个空集合，空集合的布尔值是False
print(s)
s={}
print(s,type(s))  # {} <class 'dict'>s=set('helloworld')
print(s)   # {'l', 'd', 'r', 'e', 'h', 'o', 'w'} 无序不重复s2=set([10,20,30])
print(s2)  # {10, 20, 30}s3=set(range(1,10))
print(s3)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

集合元素的操作方法

s3=set(range(1,10))
print(s3)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}# 集合属于序列中的一种
print('max:',max(s3))   # max: 9
print('min:',min(s3))   # min: 1
print('len:',len(s3))   # len: 9print('9在集合中存在吗？',(9 in s3))  # 9在集合中存在吗？ True
print('9在集合中不存在吗？',(9 not in s3))   # 9在集合中不存在吗？ Falsedel s3
print(s3) # NameError: name 's3' is not defined. Did you mean: 's'?

A={10,20,30,40,50}
B={30,50,88,76,20}# 交集操作
print(A&B)  # {50, 20, 30}
# 并集操作
print(A|B)  # {40, 10, 76, 50, 20, 88, 30}
# 差集操作
print(A-B)  # {40, 10}
print(B-A)  # {88, 76}
# 补集操作
print(A^B)  # {10, 88, 40, 76}
print(B^A)  # {40, 10, 88, 76}

集合的相关操作方法

A={100,10,20,30}
# 向集合中添加元素
A.add(40)
print(A)   # {100, 40, 10, 20, 30}# 删除集合中的元素
A.remove(20)
print(A)   # {100, 40, 10, 30}
A.pop()
print(A)   # {40, 10, 30}# 清空集合中所有元素
# A.clear()
# print(A)   # set()# 集合中的遍历
for item in A:print(item)  # 40 10 30# 使用enumerate()函数
for index,value in enumerate(A):print(index,'-->',value)
#输出结果：
# 0 --> 40
# 1 --> 10
# 2 --> 30# 集合的生成式
s={i for i in range(1,10)}
print(s)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}s={i for i in range(1,10) if i%2==1}
print(s)  # {1, 3, 5, 7, 9}

字典（dict）✅ 键值对，类似 Java 中的 Map

key --> value
字典中的键要求是不可变的序列(字符串、整数、浮点、元组都可以)，列表是不允许作为字典的键(它的可变的)

person = {"name": "Alice", "age": 25}
person["name"]       # -> "Alice"
person["age"] = 26   # 修改

注意事项:

字典中的key是无序的,
Python3.5及其之前的版本字典的key在输出时无序，
但是从Python3.6版本之后Python解释器进行了处理，所以才会看到输出的顺序与添加的顺序“一致”

字典类型创建方式

第一种使用{}直接创建字典

d={key1:value1,key2:value2,key3:value3}

第二种使用内置函数dict()创建字典

dict(key1=value1,key2=value2…)

# 使用参数创建字典
d=dict(cat=10,dog=20)
print(d)   # {'cat': 10, 'dog': 20}

t=(10,20,30)
print({t:10})   # {(10, 20, 30): 10}  t是key，10是value,元组是可以作为字典中的key的

列表不能作为字典的键

字典元素的max()、min()、len() 和删除

字典元素的访问和遍历

d={'hello':10,'world':20,'python':30}
# 访问字典中的元素
# （1）使用d[key]
print(d['hello'])  # 10# (2)d.get(key)
print(d.get('hello')) # 10

取值时，（1）d[key] 和 (2)d.get(key) 是有区别的
如果key不存在

1. d[key]会报错
2. d.get[key]可以指定默认值

d[key]会报错

d.get[key]可以指定默认值

遍历字典元素

字典相关操作方法

d={1001:'小米',1002:'小明',1003:'小红'}
print(d)# 想字典中添加元素
d[1004]="小磊"
print(d)# 获取字典中所有的key
keys=d.keys()
print(keys)        # dict_keys([1001, 1002, 1003, 1004])
print(list(keys))    #  [1001, 1002, 1003, 1004]
print(tuple(keys))   #  (1001, 1002, 1003, 1004)# 获取字典中所有的value
values=d.values()
print(values)         # dict_values(['小米', '小明', '小红', '小磊'])
print(list(values))    # ['小米', '小明', '小红', '小磊']
print(tuple(values))   # ('小米', '小明', '小红', '小磊')# 如何将字典中的数据转换成key-value的形式，以元组的方式进行展现
lst=list(d.items())
print(lst)  # [(1001, '小米'), (1002, '小明'), (1003, '小红'), (1004, '小磊')]d=dict(lst)
print(d)   # {1001: '小米', 1002: '小明', 1003: '小红', 1004: '小磊'}# 使用pop函数
print(d.pop(1004))  # 小磊
print(d)   # {1001: '小米', 1002: '小明', 1003: '小红'}print(d.pop(1008,'不存在'))# 随机删除
print(d.popitem())  # (1003, '小红')
print(d)   # {1001: '小米', 1002: '小明'}# 清空字典中所有的元素
d.clear()
print(d)  # {}# python中一切皆对象，每个对象都有一个布尔值
print(bool(d))   # False 空字典的布尔值为False

字典类型生成式

列表、元组、字典、集合的区别

正则表达式

元字符

限定符

其他字符

re模块

re是python中的内置模块，用于实现python中的正则表达式操作。

match函数的使用

import re   # 导入re模块
pattern='\d\.\d+'  #  +限定符，\d 0-9数字出现1次或多次
s='I study Python 3.11 every day' # 代匹配字符串
match=re.match(pattern,s,re.I)  # 从头开始查找
print(match)   # None， 因为开头没有数字所以为nones2='3.11I study Python every day'
match2=re.match(pattern,s2,re.IGNORECASE)
print(match2)  # <re.Match object; span=(0, 4), match='3.11'>  /找到了，还告诉了范围span=(0, 4)print('匹配值的起始位置：', match2.start())    # 匹配值的起始位置： 0
print('匹配值的结束位置：', match2.end())      # 匹配值的结束位置： 4
print('匹配区间的位置元素：', match2.span())   # 匹配区间的位置元素： (0, 4)
print('待配区间的字符串：', match2.string)     # 待配区间的字符串： 3.11I study Python every day
print('匹配的数据：', match2.group())         # 匹配的数据： 3.11

函数的定义和调用

自定义函数

 def 函数名词 (参数列表):函数体[return 返回值列表]

def get_num(num):   # num是形式参数s = 0for i in range (1,num+1):s+=iprint(f'1到{num}之间的累加和是：{s}')# 函数的调用
get_num(10)      # 1到10之间的累加和是：55     # 10是实际参数
get_num(100)     # 1到100之间的累加和是：5050
get_num(1000)    # 1到1000之间的累加和是：500500print(get_num(1))   # None

其中 get_num(num) 中num是形式参数，get_num(10)中 10，100…是实际参数

如果一个函数没有通过return显示的返回一个内容，python也会默认的给此函数返回一个“None”，可以通过print() 函数答应这个默认的返回值

变量的作用域

局部变量的使用

def calc(a,b):x=5s=x+a+breturn sprint(calc(10,20))  # 35 
# print(x)    # x是calc(a,b)内部定义的，所以打印会报错NameError: name 'x' is not defined  

全局变量的使用

a=100def calc(x,y):s=a+x+yreturn s
print(a)                     # 100
print(calc(10,20))      # 130
print("--"*30)def calc1(x,y):a=200        # 局部变量命名与全局变量重名s=a+x+y      # a=200参与了此函数中的计算，也就是说当局部变量命名与全局变量重名时，局部变量的优先级更高。return s
print(a)                     # 100
print(calc1(10,20))    # 230
print("--"*30)def calc2(x,y):global b    # b是在函数中定义的变量，但是使用了global关键字声明，此时b就变成了全局变量b=300       # 声明和赋值，必须是分开编写的s=b+x+yreturn s
print(b)      # NameError: name 'b' is not defined
print(calc2(10,20))   # 330
print(b)                    # 因为 b被global声明为全局变量，所以b可以在calc2函数之外被打印出来，但在函数被调用之前会报错

匿名函数lambda

lambda
是指没有名字的函数，这种函数只能使用一次，一般是在函数的函数体只有一句代码且只有一个返回值时，可以使用匿名函数来简化。

语法结构：result=lambda 参数列表：表达式

def calc(a,b):return a+b
print(calc(10,20))  # 30
print('+'*30)#将calc(a,b)改为匿名函数
s=lambda a,b:a+b    # 此时s就是一个匿名函数
print(type(s))      # <class 'function'>#调用匿名函数
print(s(10,15))
print('@'*30)

# 正常的列表循环取值
lst=[5,10,15,35,55]
for i in range(len(lst)):print(lst[i])
print('++'*30)# 使用lambda匿名函数取值
for i in range(len(lst)):result=lambda x:x[i]   # 根据索引取值，result的类型是function, x是形式参数print(result(lst))     # lst是实际参数

# 对列表按照score分数排序
student_score=[{'name':'小明','score':92},{'name':'红红','score':73},{'name':'濛濛','score':100},{'name':'蕾蕾','score':69},
]
student_score.sort(key=lambda x:x.get('score'),reverse=True)
print(student_score)   # [{'name': '濛濛', 'score': 100}, {'name': '小明', 'score': 92}, {'name': '红红', 'score': 73}, {'name': '蕾蕾', 'score': 69}]