python基础

01517

python安装

Python安装windows环境

Python下载

官网地址：https://www.python.org/

根据需要下载对应的版本。

按照注意事项：最好自定义路径，且加入到系统环境变量中，其他的都默认走就行。

图片[1]-python基础-秋风落叶
图片[2]-python基础-秋风落叶

看这个这个页面说明安装成功

图片[3]-python基础-秋风落叶

验证安装是否成功

进入到安装目录去执行exe文件

图片[4]-python基础-秋风落叶

能够打开说明安装成功，或者执行一个运算也行。

图片[5]-python基础-秋风落叶

获取随机数

#获取1-100以内的随机数，random是获取0-1之间的数,round是四舍五入
import random
print(round(random.random()*100))

MAC下注意事项

命令行敲python是不行的，需要加入对应的版本号，因为环境变量的名字不一样。

图片[6]-python基础-秋风落叶

原因如下：

图片[7]-python基础-秋风落叶

Python安装linux环境

下载地址

https://www.python.org/ftp/python/

旧环境变量

[root@wj ~]# ll /usr/bin/python*
lrwxrwxrwx. 1 root root     7 12月 15 20:56 /usr/bin/python -> python2
lrwxrwxrwx. 1 root root     9 12月 15 20:56 /usr/bin/python2 -> python2.7
-rwxr-xr-x. 1 root root 68600 9月   9 2021 /usr/bin/python2.7
[root@wj ~]# python -V
Python 2.7.5
[root@wj ~]# python2 -V
Python 2.7.5
[root@wj ~]# python2.7 -V
Python 2.7.5
[root@wj ~]#

安装

安装依赖包

yum install zlib zlib-devel libffi-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make wget

下载安装python

wget https://www.python.org/ftp/python/3.10.13/Python-3.10.13.tar.xz

解压编译安装

xz -d Python-3.10.13.tar.xz
tar -xf Python-3.10.13.tar
cd Python-3.10.13
./configure prefix=/usr/local/python3
make && make install

进入安装目录的python3设置软链接

ln -s /usr/local/python3/bin/python3.10 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3

查看下新的环境变量

[root@wj bin]# ll /usr/bin/python*
lrwxrwxrwx. 1 root root     7 12月 15 20:56 /usr/bin/python -> python2
lrwxrwxrwx. 1 root root     9 12月 15 20:56 /usr/bin/python2 -> python2.7
-rwxr-xr-x. 1 root root 68600 9月   9 2021 /usr/bin/python2.7
lrwxrwxrwx  1 root root    33 2月  28 20:22 /usr/bin/python3 -> /usr/local/python3/bin/python3.10

检查是否成功

[root@wj ~]# python -V
Python 2.7.5
[root@wj ~]# python3 -V
Python 3.10.13

注意事项

yum默认是依赖于系统自带的python，需要修改下

[root@wj ~]# vim /usr/bin/yum
#!/usr/bin/python2  #这里修改为实际为2版本的python版本即可
import sys
try:

pycharm相关设置

phthon解释器配置

图片[8]-python基础-秋风落叶

字体大小调节

图片[9]-python基础-秋风落叶

主题背景设置

图片[10]-python基础-秋风落叶

快捷键

ctrl+d 直接复制当前选项，在后面追加。

ctrl + alt + l 按照pep8规范进行代码格式化 windows系统

Option + Command + l 对MAC系统

ctrl + / 快速注释 windos系统

cmd + / 快速注释 mac系统

tab 向后推4个字符

shift+tab 向前推4个字符

中文编码

pycharm 设置gbk setting – editor – file encodings

python基础入门

语句分隔符

默认是回车换行符，每行输出一条语句
print ("hello word")
print (1+1)

分号可以作为分隔符，这个方式不推荐，不易于阅读
print ("hello word");print (1+1)

注释

单行注 使用#开头为注释

#获取100以内的随机数，random是获取0-1之间的数
import random
print(round(random.random()*100))

多行注释

"""
这里面是注释
"""

变量

变量多次使用

a = 1
b = 2
c = a + b
print(c)
print(a + b)

变量修改

a = 10
a = 20
print(a)
结果：
20

变量命名规范

变量只能字母 数字 下划线 ，不能以数字开头。

#两种方式，喜欢哪个用哪个
my_first_name = "王"
myFirstName = "王"

变量修改

#在局部修改全局变量
a = 10
def te():
    global a
    a = 200
    print(a)
te()
#200

基本数据类

整型和浮点型

#整型
ret = type(10)
print(ret)
结果：
<class 'int'>
#浮点型
ret = type(3.14)
print(ret)
或者这样写也行
print(type(3.14))
结果：
<class 'float'>

布尔类型

print(4 > 9)
print(type(4 > 9))
结果:
False
<class 'bool'>

print(9 > 4)
print(type(9 > 4))
结果:
True
<class 'bool'>

print(bool(1))
print(bool(-1))
print(bool(0))
结果:
True
True
False

字符串类型 ” “

字符串基本创建
# 方式1
s1 = "hello 王"
print("方式1:")
print(s1)
# 方式2
print("方式2:")
s2 = 'hello 李'
print(s2)
# 方式3 注意：没有赋值变量就是注释
print("方式3:")
s3 = """hello 赵"""
print(s3)
# 方式4
s4 = """ 1.购买道具
2.攻击
3.逃跑
4.退出
"""
print("方式4:")
print(s4)

结果:
方式1:
hello 王
方式2:
hello 李
方式3:
hello 赵
方式4:
 1.购买道具
2.攻击
3.逃跑
4.退出

str = """这是一个段落
可以写多行
"""
print(str)

str2 = "这是一个很长的字符串" \
       "第二行还是一个字符串" \
       "可以一直写下去" \
       "其实就是一行"
print(str2)
字符串转义
#换行符\n
s1="字符\n串"
print(s1)
结果:
字符
串

#转义特殊符号
s2='let\'s go !'
print(s2)
结果:
let's go !

#window路径打印
s3="\yun\\net\kk.txt"
print(s3)
结果:
\yun\net\kk.txt
格式化输出
# 方式1：比较low
# %s是占位的作用,s是随便写的，写啥都行
name = "秋风落叶"
age = 18
heigh = 190
print("我的名字叫%s,我的年龄%s,我的升高%scm!" % (name, age, heigh))
# 方式2 3.6版本之后才有 使用f代表格式化 和{}调用变量
print(f"我的名字叫{name},我的年龄{age},我的升高{heigh}cm!")

结果:
我的名字叫秋风落叶,我的年龄18,我的升高190cm!
我的名字叫秋风落叶,我的年龄18,我的升高190cm!
字符串序列操作

单个字符操作

# 单个字符操作
str = "hello word!"
print(str[0])  # 取第一个字符h
print(str[1])  # 取第二个字符e
print(str[-1])  # 取最后一个字符！
print(str[-2])  # 取倒数第二个字符d

切片操作

# 切片操作，多个字符操作，第一个值是开始，第二个值是结果
str = "hello word!"
print(str[6:10])  # 取出word ，包含头不包含尾
print(str[6:])  # 取出word! 缺省，代表取到最后的意思
print(str[:5])  # 取出hello，缺省，代表取到最前的意思
print(str[-11:-6])  # 取出hello ,怎么方便怎么来
print(str[0:6:2]) #取出h l o ,从第0个字符开始取，第6个位置结束，步长为2
print(str[0:5:-1]) #为空，位置不一致，取不到
print(str[:]) #全取hello word!
print(str[::-1]) #取出 !drow olleh 字符串翻转
print(str1[2:len(str1)]) #打印到最后

拼接操作

s = "hello"
t = "word!"
print(s + t)#helloword!
#这个方式有局限性，数字和字符无法拼接，只能把数字当做字符处理
s1="王"
s2="18"
print("我的姓名："+s1+"我的年龄:"+s2) #我的姓名：王我的年龄:18
print("*"*10) #打印10个星**********

字符串长度计算

#字符串的长度 元素的个数
s4 = "hello word!"
print(len(s4)) #11个元素，包括空格
s5 = "王"
print(len(s5)) #1  长度是1个字符

判断字符串是否存在

#判断字符串是否存在
s1 = "wang  w  j  王"
print("w" in s1) #True  判断w是否在s1中。
print("wa" in s1) #True
print("wangj" in s1) #False
print("h" in s1) #False
字符串的内置方法
# 字符串内置函数，只要是内置方法就可以用点。
s1 = "wang"
s2 = "WANG"
s3 = "123"
s4 = "   456 789 "
s5 = "   456789 "
s1Upper = s1.upper()  # 字符转大写 WANG
print(f"这是转大写:{s1Upper}")
print(f"这是转大写,写法2:{s1.upper()}")  # 写法2，不用设置变量，直接输出
print(f"这是转小写:{s2.lower()}")
print(f"判断是否以w开头:{s1.startswith('w')}")  # 判断是否以w开头:True
print(f"判断是否以w结尾:{s1.endswith('w')}")  # 判断是否以w结尾:False
print(f"判断是否是纯数字字符串:{s1.isdigit()}")  # 判断是否是纯数字字符串:False
print(f"判断是否是纯数字字符串:{s3.isdigit()}")  # 判断是否是纯数字字符串:True
print(f"去除两边的空格及换行符:{s4.split()}") #去除两边的空格及换行符:['456', '789']
print(f"去除两边的空格及换行符:{s5.split()}") #去除两边的空格及换行符:['456789']

str = "wangjian word"
res = str.capitalize() #首字母大写
res = str.title() #每个单词首字母大写
res = str.istitle() #判断每个单词首字母是否大写
res = str.lower() #字母变小写
res = str.swapcase() #字母变大写

# split分隔符,把字符串拆分为列表
s1 = "豫 北京 重庆 哈尔滨"
ret = s1.split(" ")  # 以空格为分隔符
print(ret)  # ['豫', '北京', '重庆', '哈尔滨']
print(f"一共有{len(ret)}城市！")  # 一共有4城市！
#join拼接符
s2 = "豫 北京 重庆 哈尔滨"
ret = s2.split(" ")  # 先用空格为分隔符，把字符串分开
pingJie="-".join(ret) #在用join以-进行拼接
print(pingJie) #豫-北京-重庆-哈尔滨

# 查找位置
s1 = "豫 北京 重庆 哈尔滨"
st = s1.find("北京")  # find查找北京在哪个位置
st2 = s1.find("ha")
#st3 = s1.index("f")  # index用法和find一样，区别是如果没有找到会报错
print(st)  # 打印具体位置索引 结果为 2
print(st2)  # 找不到为报-1  结果为-1
#print(st3)  # substring not found

# 计数
s1 = "豫 北京 北京 重庆 哈尔滨"
con = s1.count("北京") #查找北京出现了几次
print(con) #2次
#替换
s2 = "豫 北京 北京 重庆 哈尔滨"
new = s2.replace("豫","河南") #把豫变为河南
new1 = s2.replace("北京","京",1) #只替换一次，把查到的第一个替换掉即可
print(new) #河南 北京 北京 重庆 哈尔滨
print(new1)#豫 京 北京 重庆 哈尔滨

统计与查找
str = "wangjian word 王建"
#res = str.count("w") #统计w出现的次数
#res = str.find("o") # 查找o下标在哪个位置,只匹配第一次匹配的位置
#res = str.find("o",4) #从第4个位置开启匹配
res = str.find("o",1-4) #表示在1-4的位置匹配[1,4)  找不到返回-1
print(res)

判断开头和结尾
str = "wangjian"
#res = str.startswith("w") #判断是否是w开头
# res = str.startswith("g",3) #判断第3个位置是否是w结束的
# res = str.startswith("g",3,5) #判断第3-5的位置是否是g结束的
#res = str.endswith("w") #判断是否是w结尾
res = str.endswith("w",-4,-1) #判断-4-1是否是w结尾
print(res)

#res = "  "
#res = "\t \r\n"
#判断字符串中是否只包括空白
#print(res.isspace())
#res = "abc"
res = "8"
#判断字符串至少有一个字符串并且所有字符都是字母返回true
#print(res.isalpha())
#判断是不是数字加字符，全字符或者全数字true
print(res.isalnum())
#检测字符串是否是以数字组成，必须是纯数字
print(res.isalnum())
#检测字符串只包含数字则返回真
print(res.isdigit())
#检测字符串中只包括数字字符，返回真
print(res.isnumeric())

查找与替换

#replace 替换字符串（第三个参数选择替换的次数）
#str = "王 建 中 国 王"
#res = str.replace(" ","/") #把空格替换成/
#res = str.replace("王","李",1) #把王变成李，只替换第一个
#strip 默认去掉首尾两边的空白符
#lstrip 去掉左侧的空白符
#rsrip 去掉右侧的空白符
str = "\r wang \t \n"
print(str)
res = str.strip()
print(res)

长度填充

#字符串长度
str = "wang"
res = len(str)
print(res)
#center填充字符串，默认填充空格
res1 = str.center(10,"_")
print(res1)

编码与解码

#max 返回字符串中编码最大的字母
#mix 返回字符串中编码最小的字母
str = "王建中国"
print(max(str))
print(min(str))

#unicode内置编码打印ord
print("'王'的编码",ord("王"))
#chr 给对于的编码，打印字符
print(chr(890))

str = "王建中国"
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
print("utf-8编码:",str_utf8,type(str_utf8))
print("gbk编码:",str_gbk,type(str_gbk))

print("utf-8解码：",str_utf8.decode('UTF-8','strict'))
print("gbk解码:",str_gbk.decode('GBK','strict'))

运算符

# 计算运算符 加减乘除 + - * 、
print(2 + 5)  # 7 求和
print(5 / 2)  # 2.5 求除
print(5 % 2)  # 1 求余
********************
# 判断奇偶数
num = 23
print(num % 2 == 0)  # False 为奇数
# 比较运算符 > < >= <= == !=
# 赋值运算符 赋值= 自加+= 自减-= 自乘*= /= %=
# 逻辑运算符  and or not
# 成员运算符 in
print(f"判断5在不在元素里面:{5 in [1, 2, 3]}")  # 判断5在不在元素里面:False
********************
# 逻辑运算符
chinese = 148
math = 150
# and 两个同时满足
print(chinese == 150 and math == 150)  # False
# or 一个满足就行
print(chinese == 150 or math == 150)  # True
# 范围判断
print(chinese > 130 and chinese < 150)  # True
print(chinese > 149 and chinese < 150)  # False
print(149 < chinese > 150)  # False  简写版本
# 登录判断
user = "root"
passwd = 123

username = input("请输入用户名:")
userpasswd = input("请输入密码:")
print(user == username and userpasswd == passwd)
# 结果：
# 请输入用户名:123
# 请输入密码:456
# False

#条件嵌套
a = 10
b = 20
ab = 30
print(ab > 40 or (a >10 and b >10))#False
print(ab >= 30 or (a >10 and b >10))#True

高级数据类型

列表[ ]()

  • 对存储的格式没有任何要求
  • 是一个可以变化的数据类型
创建列表
写法1 直接写[] 
写法2 () 都可以

#方法1：直接赋值
namelist = []
print(namelist,type(namelist))

namelis1 = ["王建","张三"]
print(namelis1)
#打印元素,及类型
print(namelist1[0],type(namelist1[0]))

#方法2：通过list()函数
a = list()
print(a,type(a))
b = list("王建")
print(b)
c = list(range(10))
print(c)
d = list(range(2,-3,-1))
print(d)

方法3：通过列表推导式创建列表
e = [x*2 for x in range(5)]
print(e)
列表元素操作
#列表切片
list2 = [10,20,30,40,50]
print(list2[0]) #打印第一个元素
print(list2[0:3]) #打印前三个元素
print(list2[2:5:1]) #打印2-5之间的元素，步进为1
lst = ["192.168.1.1", "192.168.1.2", "192.168.1.3"]

ip1 = lst[0: 2]  # 取出第一个和第二个元素['192.168.1.1', '192.168.1.2']
ip2 = lst[::-1]  # 倒着显示['192.168.1.3', '192.168.1.2', '192.168.1.1']

#打印遍历元素
namelist = ["小张","小王","小李"]
for name in namelist:
    print(name)

namelist = ["小张","小王","小李"]
i = 0
while i < len(namelist):
    print(namelist[i])
    i += 1
    
namelist = ["小张","小王","小李"]
print(max(namelist))
print(min(namelist))

#求和
list = [10,20,30]
print(sum(list))

增加元素

#增追加append,在末尾,append是没有返回值的
namelist = ["小张","小王","小李"]
print("--------增加前数据------")
for name in namelist:
    print(name,end="\t")
# nametemp = input("\n请输入增加的名字:")
# namelist.append(nametemp)
namelist.append("小付")
print("")
print("--------增加后数据------ ")
for name in namelist:
    print(name,end="\t")

a = [1,2]
b = [3,4]
a.append(b) #讲列表当做一个元素，加入到a列表中
print(a)
[1, 2, [3, 4]]

#extend
a = [1,2]
b = [3,4]
a.extend(b)
print(a)
[1, 2, 3, 4]

#+操作
a = [10,20,30]
b = [40,50]
res = a + b
print(res)
[10, 20, 30, 40, 50]


#[*]操作
a = [10,20,30]
b = a * 3
print(b) 
[10, 20, 30, 10, 20, 30, 10, 20, 30]

#insert插入
a = [10,20,30]
a.insert(1,3) #第一个变量表示下表，第二个表示元素
print(a)
[10, 3, 20, 30]

#合并两个列表中的数据
lst1.extend(lst)#两个列表lst1和lst的里面的数据合并，['c', 'a', 'b', '192.168.1.1', '192.168.1.2', '192.168.1.3']

删除元素

#del 删除  pop 弹出 remove 移除
a = [10,20,30]
#del a[1] #删除下表为1的值
#a.pop() #默认会把最后一个值，弹出，有返回值
#tanchu = a.pop(0) #把下标为0的值弹出 删除第一个元素,这个可以有返回值，知道是谁被删除了
#print("被弹出的元素是：",tanchu)
#print(a)
a.remove(10) #直接删除某个值，如果有重复的值，默认删除第一个，没有返回值
print(a)
修改元素
a = [10,20,30]
a[1] = 100 #修改下标为1的元素，值为100
print(a) #[10, 100, 30]

查找元素

a = ["王","李"]
chazhao = input("请输入你要查找的数字: ")
if chazhao in a:
    print("你在元素中找到的数据")
else:
    print("没有找到")

a = ["a","b","c","d"]
print(a.index("a"))  #拿到a的下标
print(a.index("b",1,4))  #拿到a的下标,从第一个位置开始，第4个位置结束

a = ["a","b","c","d"]
print(a.count("a")) #查找a出现了几次
排序和反转
a = ["1","4","2","3"]
print(a)
#a.reverse() #d倒序打印一遍
#a.sort() #排序，默认升序排列
a.sort(reverse=True) #降序
print(a)
列表的嵌套（二维列表，三维列表)
a = []
#print(len(a)) #0
a = [[],[],[]]
print(len(a)) #3

zhangsan = ["张三",18,"男"]
lisi = ["李四",20,"男"]
namelist = [zhangsan,lisi]
#print(namelist) #[['张三', 18, '男'], ['李四', 20, '男']]
#print(namelist[0][0]) #第一个列表的，第一个元素
for person in namelist:
    print(person)
    # ['张三', 18, '男']
    # ['李四', 20, '男']
    #拿出每个元素
    for i in person:
        print(i,end = ",")
        print()
深浅拷贝
# num1 = [1,2,3]
# num2 = num1
# num1.append(4)
# print(num1,id(num1))
# print(num2,id(num2))
# [1, 2, 3, 4] 1953534371264
# [1, 2, 3, 4] 1953534371264

#浅拷贝
# num1 = [1,2,3]
# num2 = num1.copy()
# print(num1,id(num1))
# print(num2,id(num2))
# [1, 2, 3] 2384541312448
# [1, 2, 3] 2384541282304

#深拷贝，完全隔离，独立
import copy
num1 = [1,2,3]
num2 = copy.deepcopy(num1)
print(num1,id(num1))
print(num2,id(num2))

元组( )

创建元组
#创建元组
tup1 = ("a","b","c")
print(tup1,type(tup1))#('a', 'b', 'c') <class 'tuple'>
元组拆包
a,b,c = (1,2,3)
print(a)#1
print(b)#2
print(c)#3

备注：拆包的话，集合，列表也可以


#增,无法修改（其实是拼接）
# t = (1,2)
# t1 = ("abc","ddd")
# t2 = t + t1
# print(t2)
#删除（删除的是元祖对象,而不是元素）
# t = (1,2)
# del t
# print(t)
#改（不行,里面有可变类型的话，可以修改）
# mylist = ["A","B"]
# t = (10,20,mylist)
# print(t)
# mylist[0] = "c"
# print(t)
#查
# t = (1,2,3,4,5)
# print(t)
# print(t[0])
# print(t[-1]) #访问最后一个元素
# print(t[1:2]) #左闭右开

# t = (1,2,3,4,5,3)
# if 3 in t:
#     print("true")
# else:
#     print("false")

# t = (1,2,3,4,5,3)
# print(t.count(3))

#转化
s = "中国"
tup = tuple(s)
print(tup,type(tup))

字典{ }

#字典的定义
a = {}
print(a,type(a))

a = {"name":"王建","age":18}
print(a,type(a))

#查找，通过键访问
a = {"name":"王建","age":18}
print(a["name"]) #如果没有，则报错
print(a.get("name")) #这个方式比较常用，如果没有返回none
print(a.get("gend","m")) #如果没有值，就返回m

#通过列表创建字典
namelist = ["小王","小白","小张"]
#dic1 = {}.fromkeys(namelist) #默认值为none
dic1 = {}.fromkeys(namelist,"颜值高") #给固定的值
print(dic1) #{'小王': '颜值高', '小白': '颜值高', '小张': '颜值高'}

#增
# a = {"name":"王建","age":18}
# a["id"] = 10
# print(a)
#删
a = {"name":"王建","age":18}
# # del a["name"] #删除元素
# del a #直接删除字典
#a.clear() #清除元素
name = a.pop("name") #弹出name的值，但是显示时，键和值都不显示
gen = a.pop("gen","不存在改键") #删除一个不存在的键，会报错，可以返回指定的默认值
gent = a.popitem() #删除最后一个键值对，返回的是元祖类型
print(gen,a) #王建 {'age': 18}

集合

#定义集合,无序的,只能存放可变元素,不能放字典、列表类型数据
# a = set() #空集合
# #a = {1,2,3}
# print(a,type(a)) #{1, 2, 3} <class 'set'>
#去重,自动去重
# a = {1,2,3,3,4}
# print(a)
#增
# a = {1,2,3}
# # print(a)
# # a.add(4) #方式1
# #a.update("ac") #方式2  {'c', 1, 2, 3, 'a'}
# b = ["a","b"]
# a.update(b)
# print(a) #{1, 2, 3, 'b', 'a'}

#删
# clear remove（只有一个参数,不支持，不可以设置默认值） pop(随机弹出一个)
#discard ,对比remove，如果不存在不报错。
#改，变相删除，先删除后增
a = {1,2,3}
a.remove(1)
a.add(4)
print(a) #{2, 3, 4}
#查,遍历 for 循环
a = {"a","b","c",}
res = "a" in a #not in
print(res) #True

数据类型对比

图片[11]-python基础-秋风落叶

流程控制

顺序语句

分支语句

案例1: 双分支语句

# 案例1 双分支语句
age = int(input("请输入你的年龄:"))
if age >= 18:
    print("可以看成人电影")
    print("腾讯区")
    print("优酷区")
    print("爱奇艺区")
else:
    print("只能看青少年电影")
    print("天线宝宝")
print("欢迎收看")

案例2 :多路分支语句

# 案例2 多路分支
# BMI <18.5 偏瘦 ， 18.5-24.0  正常 ，24.0-28 超重，大于28 肥胖，
height = float(input("请输入你的身高[米]:"))
weight = float(input("请输入你的体重[公斤]:"))
BMI = weight / height ** 2
if BMI < 18.5:
    print("您的体重偏瘦")
elif 18.5 < BMI < 24.0:
    print("您的体重正常，你很棒！")
elif 24 < BMI < 28:
    print("您的体重超重，请注意减肥")
else:
    print("您的体重是属于肥胖，请注意减肥")
print(BMI)

案例3：分支嵌套

# 案例3：分支嵌套
pid = input("请输入您的身份证号:")
# 先判断身份证号是不是18位
if len(pid) == 18:
    print(f"打印个人基本信息,您的身份证号是:{pid}")
    # 打印性别，身份证号倒数第二位如果是偶数 则是女的，否则是男的
    num = int(pid[-2])  # 取倒数第二个
    if num % 2 == 0:  # 判断奇偶数
        print("此身份证是女的")
    else:
        print("此身份证是男的")
    # 打印籍贯
    iguana = pid[:6]  # 取出前6个字符
    if iguana == "412829":
        print("籍贯是：河南驻马店")
    else:
        print("其他的籍贯，以后慢慢在查询吧")
else:
    print("身份证位数输入有误，请重新输入！")

while 条件判断

死循环 不要乱用

#死循环 不要乱用
while True:
    print("hello word")

# 有效循环
n = 0
while n < 3:
    print("hello word")
    n += 1

打印10次

n = 1
while n <= 10:
    print(n)
    n += 1

打印1-10

#方式1
n = 0
while n < 10:
    n += 1
    print(n)

#方式2
n = 1
while n <= 10:
    print(n)
    n += 1
#打印10-1
n = 10
while n >= 1:
    print(n)
    n -= 1

for 遍历基于容器

#遍历字符串
s = "abcd"
for i in s:
    print(i)
#遍历列表
s = [1,2,3,4,5]
for i in s:
    print(i)

range循环打印

range(开始位置，结束位置，步长)

#range循环 打印1-2
for i in range(1,3):
    print(i)
结果：
1
2

打印奇偶数

#打印偶数
for i in range(2,10,2):
    print(i)
结果：
2
4
6
8

#打印奇数
for i in range(1,10,2):
    print(i)
结果：
1
3
5
7
9

倒着打印

#倒着打印
for i in range(5,1,-1):
    print(i)
5
4
3
2

拼接

s = ''
for i in range(5):
    s+=str(i)
print(s)  #01234

随机验证码案例

#随机生成一个5位数的验证码
# 随机数
import random
# 随机打印出26个字母以及数字
import string
s = ''
for i in range(5):  # 循环打印5次
    # choice方法会在序列里面选择一个打印出来
    # char = random.choice("0123456789abcdef") #手动敲字符太累
    # print(string.ascii_lowercase)  # 打印abcdefghijklmnopqrstuvwxyz
    # print(string.ascii_uppercase)  # 打印ABCDEFGHIJKLMNOPQRSTUVWXYZ
    # print(string.digits)  # 随机打印0123456789
    # 开始拼接
    char = string.ascii_lowercase + string.ascii_uppercase + string.digits
    # print(char)  # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
    # 在随机取出来一个
    randomChar = random.choice(char)
    # print(randomChar)
    s += randomChar
print(s)

求100以内数的和

# 累加和案例
# 1+2+3+...1000
sum = 0
for i in range(1, 101):
    sum += i
print(sum)

求100以内的偶数和

# 求100以内的偶数和
su = 0
for i in range(1, 101):
    if i % 2 == 0:
        su += i
    else:
        pass  # 什么都不做的意思
print(su)

退出整个循环break

#break 退出整个循环
for i in range(1,11):
    if i == 3:
        break
    print(i)
结果：
1
2

打印圆的面积

# 打印半径为1m-100m的圆的面积
for r in range(1, 101):
    # 计算圆的面积
    area = .1415962 * r ** 2
    print(f"半径为{r}的圆的面积是:{area}")

#升级版 #在其中找到第一个面积大于1000的半径值
for r in range(1, 101):
    # 计算圆的面积
    area = 3.1415962 * r ** 2
    # 在其中找到第一个面积大于1000的半径值
    if area > 1000:
        print(f"半径为{r}的圆的面积是:{area}")
        break

退出当前循环continue

for i in range(1, 5):
    if i == 3:
        continue
    print(i)  # 1  2  4

摇车牌案例

完整版案例

import random  # 随机数
import string  # 随机打印出26个字母以及数字
"""
需求:
1.允许用户最多选3次
2.每次放出5个车牌供用户选择
3.车牌是大写字母和数字组合
4.车牌是6个字符组合
"""
count = 0
while count < 3:  # 代表可以选3次
    car_nums = []
    for i in range(5):  # 循环5次，生成5组车牌
        # 生成的车牌放在一个列表中
        # 车牌的第一个字母 必须大写 string.ascii_uppercase代表生成大写字母  random.choice代表随机在里面找一个
        n1 = random.choice(string.ascii_uppercase)
        # 车牌的后面5个字母 string.digits代表生成0-9的数字，然后和字母拼接，在用随机数取出5个，最后用join转字符
        n2 = "".join(random.sample(string.ascii_uppercase + string.digits, 5))
        car_num = f"皖{n1}·{n2}"
        car_nums.append(car_num)  # 把生成的车牌，累加起来存到一个列表中
        print(i + 1, car_num)  # 打印序号 及车牌
    if count == 0:
        print("温馨提示:当前是第一次选择")
    elif count == 1:
        print("温馨提示:当前是第二次选择")
    elif count == 2:
        print("温馨提示:当前是第三次选择")
    ch = input("请输入你喜欢的车牌:").strip()  # strip 代表去除输入两边多余的空格 回车
    if ch in car_nums:  # 代表选择的车牌在列表中
        print(f"恭喜你选择了新车牌号:{ch}")
        exit("祝您好运!!!")
    else:
        if count == 2:
            print("你选择的车牌不正确，且三次选择已用完，自动退出程序")
            break
        print("你选择的车牌不正确请重新输入")
    count += 1

记录版本

import random  # 随机数
import string  # 随机打印出26个字母以及数字

"""
需求:
1.允许用户最多选3次
2.每次放出20个车牌供用户选择
3.车牌是大写字母和数字组合
4.车牌是6个字符组合
"""
# 方式1：
s = ""  # 这是要生成的车牌号，设置为0
str1 = string.ascii_uppercase  # 生成26个大写字母
str2 = string.digits  # 生成0-9数字
str3 = str1 + str2  # 把字母和数字进行拼接
for i in range(6):  # 循环6次，代表显示6个字符的车牌
    str4 = random.choice(str3)  # 随机显示一个拼接后的字符
    s += str4  # 每次显示一个进行拼接操作
print(s)  # 打印6个字符的车牌

# 方式2：
str1 = string.ascii_uppercase  # 生成26个大写字母
str2 = string.digits  # 生成0-9数字
str3 = str(str1 + str2 ) # 把字母和数字进行拼接,同时转换为字符
s4 = random.sample(str3, 6)  # 在字符串中，产生6个值
print("".join(s4))  # 打印6个字符的车牌

生产一个随机密码

编码介绍

unicode编码
是一个万国码，支持所有国家的语音，跟所有国家的编码有映射关系，2-4字节来存一个字符，比ASCII编码，要多一倍。

utf-8编码
一个英文占1个字节 西欧的占2个字节 中文占3个字节，是一个可变长的编码
主要存到文件中，或者网络发送中，但是在内存中依然是unicode这是在py3的一个特点
py3中，文件默认编码都是UTF-8
在py2中，内存里面的字符默认是ASCII，py是1989年的，哪个时候没有unicode，默认是不支持中文的。
因为ASCII码只支持英文

mac linux 默认是utf-8
mac 控制台输入locale 可以查看编码
windows中国版本 ，默认是gbk
# -*- encoding:gbk -*- #指定字符集

decode 解码
encode 编码

常用模块

random

可以产生指定范围内的随机数、字符串等

import random
s1 = random.choice("abcd") #在其中随机输出一个
s2 = "abcded"
s3 = random.sample(s2,3) #在字符串中，随机显示3个
s4 = random.randint(1,100) #打印1-100的一个随机数
print(s1)
print(s3)#['d', 'a', 'e']
print(s4)

文件操作

案例1：

with open("hello.txt", mode="w", encoding="utf-8") as f:
    f.write("a")
    f.write("b")

字符操作

  • r 以只读的方式打开文件，也是默认模式
  • w 打开一个文件用于写入，没有则创建
  • a 打开一个文件用于追加内容
  • r+ 打开一个文件用于读写，文件指针将会放在文件的开头
  • w+ 打开一个文件用于读写，没有则创建
  • a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模
    式。如果该文件不存在，创建新文件用于读写

写入操作

创建一个文件,用于读写，py3默认都是utf-8，不用加字符集

f = open("秋风落叶.txt","w+") #这样一个秋风落叶.txt文件就创建好了
py2中 需要指定字符集，不然容易乱码
f = open(r"D:\pythondemo\test.txt","w",encoding="GBK")

往文件中添加内容，单行操作

f = open("秋风落叶.txt","w+")
f.write("今天天气怎么？")
f.close() #关闭文件

多行写入

#写入多行
#f = open(r"D:\pythondemo\test.txt","w",encoding="GBK")
#f.write("哈哈\n你好\n世界\n") #方式1，通过换行符
# cont = ["王建\n","中国\n"]
# f.writelines(cont)  #方式2:
# f.close()

#不用每次加入\n 推荐此方式
f = open(r"D:\pythondemo\test.txt","w",encoding="GBK")
cont = ["王建","中国"]
f.write("\n".join(cont)) #方式3
f.close()

访问模式 a 追加文件 ,也可用a+

f = open("0226.txt","a+")
print(f.read())
f.write("\n北京")
f.write("\n上海")
f.close()

强制把缓冲的数据写入到硬盘

f = open("0226.txt", "w+")
f.write("hello\n")
print("返回光标当前位置", f.tell())
f.write("hello\n")
print("返回光标当前位置", f.tell())
f.seek(7)
f.write("----")
f.flush()  # 强制把缓冲区的数据写入到硬盘，在执行命令行时，最后可以添加这个

跳到某个位置继续写入，把后面的替换掉了，不是追加，是覆盖

f = open("0226.txt", "w+")
f.write("hello\n")
f.write("hello\n")
f.seek(3)  # 跳到第3个字符位置继续写
f.write("--")
结果：
hel--
hello

路径忽略

# f = open(r"D:\pythondemo\test.txt","w") #r 忽略所有的\线，直接访问路径
# f.write("wangjian")
# f.close()

读取操作

#2.文件的读read 把数据从文件中取到程序中
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# #date = f.read() #要有一个返回接受
# #date = f.read(2) #只读前两个字符
# date = f.read((4)) #读前4个，但是前两个已经读出来，会只显示后两个字符
# print(date)
# f.close()

#读取一行
f = open("hell")  # 如果不指定路径的话，默认是当前项目路径下
print(f.read())  # 默认是读取所有
print(f.readline())  # 默认读取第一行
f.close()

#读取每行
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# while True:
#     content = f.readline()
#     if content:
#         print(content,end="")
#     else:
#         break
# f.close()

#读取多行，一次性读取全部文件为列表，每行一个字符串元素
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# content = f.readlines()
# #print(content)
# i = 1
# for date in content:
#     print(date,end="")
#     i+=1
# f.close()
#方式2
# f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
# content = f.readlines()
# for i,date in enumerate(content):
#     print(date,end="")
# f.close()

返回指针当前所在的位置tell，字节数,我在哪

#返回指针当前所在的位置tell，字节数,我在哪
f = open("0226.txt", "w+")
f.write("hello\n")
print("返回光标当前位置",f.tell())
f.write("hello\n")
print("返回光标当前位置",f.tell())
结果：
返回光标当前位置 6
返回光标当前位置 12

seek 定位文件读取的指针所在位置(字节)，我要到哪里去

#seek 定位文件读取的指针所在位置(字节)，我要到哪里去
#seek (offset [,whence])
#offset - 开始的偏移量，也就是代表需要移动偏移的字节数
#were 可选，默认值为0
f = open(r"D:\pythondemo\test.txt","r",encoding="GBK")
con = f.read(2)
print(con)
f.seek(4) #指定的是字节数
print("当前指针所在位置:",f.tell())
f.close()

综合案例1

文件内容如下：

1. 张三 安徽 173 100 1245
2. 李四 北京 170 90 1246
3. 王五 上海 160 80 1255
4. 赵六 河南 150 70 1255
4. 胡七 安徽 140 60 1345

"""
需求：
找到学生 升高大于160 ，且体重大于80的学生
"""
f = open("学生信息")
for line in f:  # 每循环一次 ，打印一行
    line = line.split() #把每行字符串分成了一个列表
    height = int(line[3]) #取列表中第3个元素,因为是字符串，需要转换为int进行比较
    weight = int(line[4])
    if height >= 170 and weight >=80:
        print(line)
    #print(line,end="")#去除回车换行符
    #print(f.readlines()) #每行数据，变为一个列表中的元素 最终变为一个大列表
结果如下：
['1.', '张三', '安徽', '173', '100', '1245']
['2.', '李四', '北京', '170', '90', '1246']

二进制操作

二进制操作（图片、音乐、视频等）

  • rb 二进制只读模式
  • wb 二进制创建模式，若文件已存在，则覆盖旧文件
  • ab 二进制追加模式，新数据会写到文件末尾

这样你读出来的数据就是bytes字节类型的，当然写进去也必须是二进制的。

写入操作

以二机制方式写入文件

f = open("秋风落叶", "wb")  # 创建了一个名为秋风落叶的文件，以wb也就是二进制的方式写入
s = "王"  # 定义一个字符串，表示要写入的内容
f.write(s.encode("utf-8"))  # 写入的内容的字符编码,此处必须编码
f.write("测试")  # 这样写，只能报错，字符串是写不进去的。TypeError: a bytes-like object is required, not 'str'

#二进制操作（图片、音乐、视频等）
#rb:read binary  wb:write binary
#此功能可以看做是复制一个图片
#读取
fin = open("wallhaven-z8jl7w.jpg",mode="rb" ) #mode="rb" 默认可以不写
#写入
fout = open("wallhaven_bak.jpg",mode="wb")

while True:
    date = fin.read(100) #缓冲区 一次读100字节
    if date:  #不为空
   #if date != b"": 也是不为空，写法2 
        fout.write(date) #读完就写
    else:
        break

fin.close()
fout.close()

read10 读的是啥

#读取
fin = open("wallhaven-z8jl7w.jpg",mode="rb" ) #mode="rb" 默认可以不写
#写入
fout = open("wallhaven_bak.jpg",mode="wb")
date = fin.read(10)
print(date,type(date))
#以b开通表示bytes（字节）方式读取的字符串，是以十六进制表示的内容
#b'\xff\xd8\xff\xe1\x06zExif' <class 'bytes'>

文件写入过程

#文件写入过程
#数据-缓冲区-硬盘
f = open("w.txt",mode="w+",encoding="utf-8")
f.write("王建中国")
while True:
    pass
f.close()
#以上程序执行后，会创建w.txt文件，但是数据没写入，其实执行了，只是在内存用，还没写入硬盘中
#只有执行了close后，才会写入文件

#缓冲区清空的时间节点
#当文件关闭的时候，自动清空
#当整个程序运行结束的时候
#当缓冲区写满的时候
#手动清空缓冲区
f = open("w.txt",mode="w+",encoding="utf-8")
f.write("王建中国")
f.flush() #手动清除缓存，数据写入到文件
while True:
    pass
f.close()

截断

#截断
# f = open("w.txt",mode="w+",encoding="utf-8")
# for i in range(5):
#     f.write("王建中国"+str(i)+"\n") #15个字符,一个汉字3个字符，换号2个
# f.close()
# f.close()

f = open("w.txt",mode="r+",encoding="utf-8")
f.seek(24) #定位到24个字符
f.truncate() #删除24字符之后的数据
f.close()

#方式2
f.truncate(8) #直接删除8之后的数据
f.seek(0)#定位在头部
print(f.read())

文件对象是个可迭代对象

#
f = open("w.txt","r+",encoding="gbk")
print("文件名称",f.name)
print(f.mode) #文件打开的模式
print(f.writable())#文件可写 true
print(f.readable()) #文件可读

读取操作

以二进制方式读取图片

fin = open("截屏2024-02-25 21.37.19.png",mode="rb")
for line in fin:
    print(line)
结果如下：
b'#\xa4m\xcc\x1d\xcf\'\xbf\x9f\xc2=x\xd6\xa8\xd6&\x14\x
b'J\xf1\xbe\'\x1e\x87\x11:G\xf5\x1afLe\xaeB\x02\xe5\x05
.............省略........

文件修改

f = open("修改文件测试.txt","r+")#abcdefg
#需求把cd改为123
#步骤1，先把数据读取到内存中
date = f.read()#全部加载到内容
print(date)#abcdefg
#修改替换
new_data = date.replace("cd","123")
print(new_data)#ab123efg,已经写入到了内存中
#清空硬盘中的原始数据
f.seek(0) #先把光标跳转到首位
f.truncate()#截断文件，从光标之后，都进行删除，此时执行后，去查看硬盘文件为空
#把内存中的数据重新写入到硬盘
f.write(new_data)
f.close()

全局搜索替换文本脚本

# 全局搜索替换文本
import sys

old_str = sys.argv[1]  # 输入的第一个参数 旧字符串
new_str = sys.argv[2]  # 输入的第二个参数 新字符串
fileName = sys.argv[3]  # 输入的第三个参数 需要操作的文件名字
# 步骤1 打开需要操作的文件
f = open(fileName, "r+")
data = f.read()  # 把文件内容全部读取到内存中
# 步骤2 计数 以及替换文本
old_str_count = data.count(old_str)  # 查找旧字符在文件中出现了多少次
new_data = data.replace(old_str, new_str)
# 步骤3 清除磁盘上的旧的文件
f.seek(0)
f.truncate()
# 步骤3 保存内存中的新数据到硬盘上
f.write(new_data)
f.close()
if old_str_count == 0:
    print(f"当前文件中没有你要查询的文本:'{old_str}',请重新执行！")
else:
    print(f"成功把'{old_str}'替换为'{new_str}'，共修改{old_str_count}处")

脚本使用教程

[root@wj ~]# more 1.txt 
中国 安徽 包河区 安徽
[root@wj ~]# python 1.py 安徽 合肥 1.txt
成功把'安徽'替换为'合肥'，共修改2处

用户登录认证程序

"""
需求
1、要求用户输入账号密码进行登陆
2、用户账号信息保存在文件内
3、用户密码输入错误3次后锁定用户，下次在登陆，检测到是锁定的用户，则不允许登陆，提示账号已被锁定

账号信息，第一列是 用户名  第二列是密码  第三列是账号状态1是启用 0是锁定
zhangsan,123,1
lisi,456,1
wangwu,789,1
"""
# 把账号数据保存到内存中，方便调用 存为字典形式
accounts = {}
f = open("user.txt", "r")
for line in f:  # 读取文件中的每一行
    line = line.strip().split(",")
    # print(line)# 以逗号为分割符,此时是一个3列表 ['zhangsan', '123', '1'] ['lisi', '456', '1'] ['wangwu', '789', '1']
    # print(line[0]) #每个列表的第一个元素是 zhangsan  lisi wangwu
    # 存为字典形式 {'zhangsan': ['zhangsan', '123', '1'], 'lisi': ['lisi', '456', '1'], 'wangwu': ['wangwu', '789', '1']}
    accounts[line[0]] = line  # 拿到列表line[0]的第一个元素当作key {'zhangsan': ['zhangsan', '123', '1']}
    # print(line)#此时的line 就是字典中的值了
# 最终的字典形式：{'zhangsan': ['zhangsan', '123', '1'], 'lisi': ['lisi', '456', '1'], 'wangwu': ['wangwu', '789', '1']}
print(accounts)
while True:  # 用户名可以输入多次
    user = input("请输入用户名:").strip()
    if user not in accounts:
        print(f"您输入的账号【{user}】未注册,请输入注册过的用户名")
        # 如果用户名不存在就，退出当前循环，重新输入用户名，就不用输入密码了，continue必须和循环一起用
        continue
    if accounts[user][2] == "0": #代表此账号已锁定
        print(f"您输入的账号【{user}】是被锁定的账号,请联系管理员解锁,或者是请输入其它账号进行登录")
        continue
    count = 0
    while count < 3:  # 密码只能输入三次
        passwd = input("请输入密码:").strip()
        if passwd == accounts[user][1]:
            print(f"系统登陆成功,您输入的用户名是:{user}")
            exit("登录成功")
        else:
            print(f"密码输入错误,请重新输入")
        count += 1
        if count == 3:
            print(f"当前的用户名{user}密码输入达到了3次,账号已被锁定")
            # 1.先修改内存中的数据，把用户账号的状态1改为0
            accounts[user][2] = "0"
            # 此时内存中，用户的状态已修改 {'zhangsan': ['zhangsan', '123', '0'], 'lisi': ['lisi', '456', '1'], 'wangwu': ['wangwu', '789', '1']}
            # print(accounts)
            # 2.在把内存中的数据，存到文件中,并保留原来格式
            f2 = open("user.txt", "w")
            # print(accounts.items())#dict_items([('zhangsan', ['zhangsan', '123', '0']), ('lisi', ['lisi', '456', '1']), ('wangwu', ['wangwu', '789', '1'])])
            for user, val in accounts.items():  # user代表key  val代表值
                line = ",".join(val) + "\n"  # 在把列表转为字符
                # print(line)
                f2.write(line)  # 写入到文件
            f2.close()

        # print(count)

函数

定义函数及调用

#定义函数
def hanshu():
    print("-"*20)
    print("人生苦短，我学python")
    print("-" * 20)
#函数调用
hanshu()

带参数的函数

#带参数的函数
def addnum(a,b): #形参
    c = a + b
    print(c)
addnum(10,22) #实参

#案例2
import datetime

time = datetime.datetime.now().strftime("%Y-%m-%d %X")


def my_log(msg):  # 形参
    with open("my_log.log", mode="a", encoding="utf-8") as f:
        f.write(time)
        f.write(",")
        f.write(msg)
        f.write("\n")
        f.close()


print("开机中....")
my_log("服务器开机启动啦...")  # 实参，函数在调用时，参数必须要有值，不然会报错
print("nginx启动中...")
my_log("nginx启动啦...")
print("tomcat启动中...")
my_log("tomcat启动啦...")

结果：文件中内容
2024-03-07 16:15:18,服务器开机启动啦...
2024-03-07 16:15:18,nginx启动啦...
2024-03-07 16:15:18,tomcat启动啦...

带返回值的函数

#写法1 每次返回一个值
def func(fuHao, a, b):  # 有3个参数
    if fuHao == '+':
        return a + b
    elif fuHao == '-':
        return a - b
    elif fuHao == '*':
        return a * b
    elif fuHao == '/':
        return a / b
ret = func("+",5,6)
print(ret)

#写法2
def func(a, b): 
    return a + b, a - b, a * b, a / b #每次返回多个值，结果是一个元组

ret = func(5, 6)
print(ret)#(11, -1, 30, 0.8333333333333334)



#返回一个字典
def func(a, b): 
    return {"jia": a + b, "jian": a - b, "cheng": a * b, "chu": a / b}#返回一个字典类型
#jia, jian, cheng, chu = func(5, 6)
nu = func(5,6)
print(nu)#{'jia': 11, 'jian': -1, 'cheng': 30, 'chu': 0.8333333333333334}


def jianfa(a,b):
    if a<b:
        return b-a
    else:
        return a-b
print(jianfa(20,30))

return 不写返回值

#这是写了返回值
def fun():
    print("你好啊")
    #return
    print("我叫赛利亚")
    return 123
ret = fun()
print(ret)
结果：
你好啊
我叫赛利亚
12

#不写返回值
def fun():
    print("你好啊")
    return #默认返回是none ,作用是终止一个函数的运行，不给外界返回任何数据
    print("我叫赛利亚")
    return 123
ret = fun()
print(ret)
结果：
你好啊
None

不写return

def fun():
    print("你好啊")
    print("我叫赛利亚")
    #这里不写retrun 默认加上结果none
ret = fun()
print(ret)
结果：
你好啊
我叫赛利亚
None

解包拆包

#每次返回多个值，结果是一个元组，在把元组拆解成单个
def func(a, b):  # 有3个参数
    return a + b, a - b, a * b, a / b

#a = func(5,6)
#jia ,jian,cheng,chu = a
jia ,jian,cheng,chu = func(5,6)#这样写一步到位
print(jia)
print(jian)
print(cheng)
print(chu)
#结果
11
-1
30
0.8333333333333334

默认参数

def sg(name,age,addr="安徽"):
    print(name,age,addr)
sg("张三",18)
sg("李四",30,"北京")
#结果
张三 18 安徽
李四 30 北京

实参指定形参

def login(user,passwd):
    print(user,passwd)
login(user="zhangsan",passwd="1234")#实参指定形参
#结果
zhangsan 1234

动态传参

#动态位置传参
在形参上，可以用*来动态接受所有的位置参数
可以使用**来动态接受所有的关键字参数
"""
# def chi(*food):#*表示动态接受位置参数，参数名是food
#     print(food)#接受到的是元组()
# chi("小龙虾","螺狮粉")#('小龙虾', '螺狮粉')

#动态关键字传参1
def chi(*food,pei="林志玲"):
    print(pei,"陪你吃",food)#接受到的是元组()
chi("小龙虾","螺狮粉",pei="小团团")#小团团 陪你吃 ('小龙虾', '螺狮粉')

#动态关键字传参2
def chi(*food, **kan):  # *表示动态接受位置参数，参数名是food,**动态关键字参数
    print(kan, "陪你吃", food)  # food接受到的是元组()，kan接受到的是字典


chi("小龙虾", "螺狮粉", kan="小团团")  # {'kan': '小团团'} 陪你吃 ('小龙虾', '螺狮粉')

#注意
如果混搭，注意书写顺序，位置参数>*args>默认值参数>**args

#动态实参传参
ldef func(*args):
    print(args)


lst = ["香蕉", "皮蛋", "葡萄"]
func(lst)  # (['香蕉', '皮蛋', '葡萄'],) 元组里面是个列表
# 在实参可以用*号打散一个列表、元组 集合 字符串，成位置参数进行传递
func(*lst)  # ('香蕉', '皮蛋', '葡萄')  是一个元组


def fn(it):
    print(it)


fn(lst)  # ['香蕉', '皮蛋', '葡萄']
fn(tuple(lst))  # ('香蕉', '皮蛋', '葡萄') 直接转为元组

函数调用嵌套

def add2num(a,b):
    return a+b
def add3num(a,b,c):
    return add2num(add2num(a,b),c)
print(add3num(10,20,30))

函数注释及说明

def calc(a: int, b: int) -> int:
    """
    a:int 表示a的类型是什么
    ->表示 函数的返回值是什么类型
    j计算a+b的和
    :param a: 第一个数的值
    :param b: 第2个数的值
    :return: 返回a+b
    """
    return a + b


ret = calc(1, 2)

函数本质

函数也可以赋值
def fun():
    global a  
    a = 20  


fun()
an = fun
print(id(fun))  # 4309466800
print(id(an))  # 4309466800

装饰器

本质就是在不改变原有函数的基础上给函数增加新的功能，可以在开始之前也可以在之后。

案例1

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game): #wai_gua： 装饰器的名字  game：被装饰的函数
    #inner：被返回的函数，用来替代原函数
    def inner(*args,**kwargs):#*args,**kwargs，给原函数同样的参数配置
        print("----开启log外挂----")
        ret = game(*args,**kwargs) #game（） 运行原函数，ret是原函数的返回值
        print("----lol外挂关闭----")
        return ret #把原函数运行的结果反馈给调用方，在调用方看来，得到的结果依然是原函数的结果
    return inner #用来替代原函数


@wai_gua  # 使用装饰器 play_lol = wai_gua(play_lol)
def play_lol(username,passwd):
    print("我要打lol",username,passwd)
    return "打的好,返回一个妹子"

def play_dnf():
    print("我要打dnf")


ret = play_lol("admin","123456")
print(ret)
play_dnf()

"""
----开启log外挂----
我要打lol admin 123456
----lol外挂关闭----
打的好,返回一个妹子
我要打dnf
"""

案例2

flag = False  # 默认没有登录


def log():
    global flag
    while 1:
        usernmae = input("请输入用户名：")
        passwd = input("请输入密码：")
        if usernmae == "admin" and passwd == "123456":

            print("登录成功")
            flag = True
            break
        else:
            print("账号密码错误，请重新登录")


def warpper(fn):
    def inner(*args, **kwargs):
        if not flag:
            log()
        ret = fn(*args, **kwargs)
        return ret

    return inner

@warpper
def add():
    print("我要新增博客")

@warpper
def upd():
    print("我要修改博客")


add()
upd()

"""
请输入用户名：admin
请输入密码：123456
登录成功
我要新增博客
我要修改博客
"""

万能版本没有返回值的

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game):
    def inner(*args,**kwargs):#为了适用各种参数的适用
        print("----开启log外挂----")
        game(*args,**kwargs)
        print("----lol外挂关闭----")

    return inner


@wai_gua  # play_lol = wai_gua(play_lol)
def play_lol(username,passwd):
    print("我要打lol",username,passwd)


def play_dnf():
    print("我要打dnf")


play_lol("admin","123456")
play_dnf()

初始版本

# 装饰器
def wrapper(fn):  # fn是你要装饰的函数，你要给谁增加新功能
    def inner(*args, **kwargs):  # inner 可以接受所有的参数
        print("请先登陆")
        ret = fn(*args, **kwargs)  # 在运行你要装饰的那个函数
        return ret

    return inner  # 这是最关键的一句话


def add_blog():
    print("我想写一个博客")
    """
    如果我想在写博客的前面添加一个登陆验证，但是我又不想动现在已有固定稳定的代码
    在这是添加添加登陆验证的，但是需要改动目前的代码，有风险。
    """


def search_blog():
    print("我想查看博客")


add_blog = wrapper(add_blog)  # 要装饰的函数
# 从这里开始 add_blog变成wrapper里面的inner了
add_blog()

search_blog()

简版写法1

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game):
    def inner():
        print("----开启log外挂----")
        game()
        print("----lol外挂关闭----")

    return inner


@wai_gua  # play_lol = wai_gua(play_lol)
def play_lol():
    print("我要打lol")


def play_dnf():
    print("我要打dnf")


play_lol()
play_dnf()

简版2

# 需求，在打游戏之前开启外挂
# 外挂开启
def wai_gua(game):
    def inner(username,passwd):
        print("----开启log外挂----")
        game(username,passwd)
        print("----lol外挂关闭----")

    return inner


@wai_gua  # play_lol = wai_gua(play_lol)
def play_lol(username,passwd):
    print("我要打lol",username,passwd)


def play_dnf():
    print("我要打dnf")


play_lol("admin","123456")
play_dnf()

结果：
----开启log外挂----
我要打lol admin 123456
----lol外挂关闭----
我要打dnf

简版2

# 装饰器
def wrapper(fn):  # fn是你要装饰的函数，你要给谁增加新功能
    def inner():  # inner 可以接受所有的参数
        print("请先登陆")
        fn()  # 再运行你要装饰的那个函数

    return inner  # 这是最关键的一句话


@wrapper  # 这样写就是装饰器，哪里有需要，就加哪里等价于add_blog = wrapper(add_blog)
def add_blog():
    print("我想写一个博客")
    """
    如果我想在写博客的前面添加一个登陆验证，但是我又不想动现在已有固定稳定的代码
    在这是添加添加登陆验证的，但是需要改动目前的代码，有风险。
    """


@wrapper  # 这样写就是装饰器，哪里有需要，就加哪里
def search_blog():
    print("我想查看博客")


# 从这里开始 add_blog变成wrapper里面的inner了
add_blog()

search_blog()

还未归类








#可变参数，定义时作用  打包
def priinfo(name,age,*args):
    print(f"姓名:{name},年龄:{age}")
    print("作品评分:",args)
priinfo("王建",20,"男",8.9,8.7,9.0)
# 姓名:王建,年龄:20
# 作品评分: ('男', 8.9, 8.7, 9.0)

def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    print(kwargs)
priinfo("王建",20,身高=1.65,国籍="中国",出生地="驻马店")
# 姓名:王建,年龄:20
# {'身高': 1.65, '国籍': '中国', '出生地': '驻马店'}

#可变参数，调用时作用 解包
def priinfo(name,age,*args):
    print(f"姓名:{name},年龄:{age}")
    print("作品评分:",args)
#rate = [8.9,8.7,9.0]  #列表
#rate = (8.9,8.7,9.0) #元祖
rate = {8.9,8.7,9.0} #集合 默认无序
priinfo("王建",20,*rate)
# 姓名:王建,年龄:20
# 作品评分: (8.9, 8.7, 9.0)

def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    print(kwargs)
iffo = {"身高":1.65,"国籍":"中国","出生地":"驻马店"}
priinfo("王建",20,**iffo)
# 姓名:王建,年龄:20
# {'身高': 1.65, '国籍': '中国', '出生地': '驻马店'}

def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    #print(kwargs)
    for key ,value in kwargs.items():
        print(f"key是:{key}:值是:{value}")
iffo = {"身高":1.65,"国籍":"中国","出生地":"驻马店"}
priinfo("王建",20,**iffo)
# 姓名:王建,年龄:20
# key是:身高:值是:1.65
# key是:国籍:值是:中国
# key是:出生地:值是:驻马店


def priinfo(name,age,**kwargs):
    print(f"姓名:{name},年龄:{age}")
    #print(kwargs)
    for key ,value in kwargs.items():
        print(f"{key}:{value}",end="\t")
iffo = {"身高":1.65,"国籍":"中国","出生地":"驻马店"}
priinfo("王建",20,**iffo)
# 姓名:王建,年龄:20
# 身高:1.65	国籍:中国	出生地:驻马店

input输入函数

# input输入 案例1
name = input("请输入你的名字:")
age = input("请输入你的年龄:")
print(f"我的名字是:{name},我的年龄是:{age}")
# input输入 案例2
numStr1 = input("请输入数字1:")
numStr2 = input("请输入数字2:")
print(type(numStr1), type(numStr2))  # <class 'str'> <class 'str'>
num1Int = int(numStr1)
print(type(num1Int))  # <class 'int'>
num2Int = int(numStr2)
print(f"输入的数字之和是：{num1Int + num2Int}")  # 输入的数字之和是：22

print输出函数

#print输出函数,默认是空格当做分隔符
print(100,"w","王")# 100 w 王
print(100,"w","王",sep="-")# 100-w-王 修改为以-作为分隔符
print(100,"w","王",end=";")# 100 w 王; 修改换行符为分号
print(200)#100 w 王;200

根据用户输入的数字，打印相应行数的线条

#根据用户输入的数字，打印相应行数的线条
def priol():
    print("-"*30)
def prinul(num):
    i = 0
    while i<num:
        priol()
        i+=1
numm = input("请输入对应的数字：")
prinul(int(numm))

求平均数

#求3个数的平均数
def he(a,b,c):
    return a+b+c
#print(he(1,2,3))
def ave3n(a,b,c):
    return he(a,b,c)/3.0
result = ave3n(1,2,3)
print(result)

递归运算

#递归的写法
# 1、编写函数体（功能）
# 2、确定结束条件和返回值
# 3、调用函数自身，修改参数


def printNum(n):
    print(n) #执行的运算
    if n == 1: #最终结束的条件
        return #返回的数值
    printNum(n-1) #调用自身函数
printNum(100)

# 求指定位数阶乘 n! = n*(n-1)
#比如求5的阶乘：5*4*3*2*1
#分析：
#f(1) = 1 n<=1
#f(n) = f(n-1) * n n>1
def fac(n):
    if n <=1:
        return 1
    return fac(n-1) * n
print(fac(6))

#斐波那契数列，根据用户指定的项数，计算对应位置的值
#0 1 1 2 3 5 8 13
#f(n) = n n<=1
#f(n) = f(n-1) + f(n-2)

def fb(n):
    if n <=1:
        return n
    return fb(n-1) + fb(n-2)
print(fb(9))

#for写法

def feb(n):
    if n<=1:
        return n
    res = 0 #存和最终的和
    feb0 = 0 #用于存储下一次运算的内容
    feb1 = 1 #用户下一次运算的和
    for i in range(2,n+1):
        print(f"res:{res},feb0:{feb0},feb1:{feb1}")
        res = feb0 + feb1
        feb0 = feb1
        feb1 = res
    return res

print(feb(5))
# res:0,feb0:0,feb1:1
# res:1,feb0:1,feb1:1
# res:2,feb0:1,feb1:2
# res:3,feb0:2,feb1:3
# 5

变量

a = 10


def fun():
    global a  #引用全局变量，只能引用外层
    nonlocal a #引入当前函数外层的局部变量，就是有两层函数，或者多层函数
    a = 20 #此时是修改a的值，不再是创建变量a了
fun()

迭代器

是一个标准，统一了一些数据类型的循环方式.

  • 特别省内存（结合生成器来看）
  • 任何数据类型就能打印出来
  • 只能向前，不能后退
  • 一次性的，如果走到头在取，就报错
  • 如果一个数据有__iter__，我们称为可迭代对象
  • 如果一个数据有__next__，我们称为迭代器

案例1：

it = [11,22,33].__iter__()
print(it.__next__())
print(it.__next__())
print(it.__next__())
"""
11
22
33
"""

案例2：

def dtq(date):
    from collections.abc import Iterable  # 可迭代的
    if isinstance(date, Iterable):  # 判断date是否是可迭代的
        it = date.__iter__()
        while 1:  # 不知道要循环多少次
            try:
                print(it.__next__())
            except StopIteration as e:
                # print("执行完成")
                break


dtq("abc")
"""
a
b
c

####################################################
def dtq(date):
    it = date.__iter__()
    while 1: #不知道要循环多少次
        try:
            print(it.__next__())
        except StopIteration as e:
            #print("执行完成")
            break
dtq("123")
"""
1
2
3
"""

复习各种类型

# 列表
lb = [1, 2, 3]
print(lb.__iter__())  # list_iterator
# 元组
yz = (11, 22)
print(yz.__iter__())  # tuple_iterator
# 字符串
zfc = "123"
print(zfc.__iter__())  # str_ascii_iterator
# 集合
jh = {"姓:", "wang"}
print(jh.__iter__())  # set_iterator
# 字典
zd = {"name": "wang"}
print(zd.__iter__())  # dict_keyiterator

生成器

  • 在函数中如果包含了yield，通过yield来返回数据的话，这个函数就是生成器函数
  • 函数名（）此时不是在运行函数，而是是创建生成器

案例1：

def func():
    print("haha")
    yield 123
    print("helll")
    yield 456


mm = func()  # 创建了一个生成器generator
mm.__next__()  # 才会让生成器开始干活，执行到下一个yield为止
mm.__next__()
"""
haha
helll
"""

案例2：

"""
比如我需要生成9999个数据，普通方式就是直接在内存中一次性生成了
"""
lst = []
for item in range(9999):
    lst.append(item)
print(lst)
"""
改进版本，用一个拿一个 不需要一次性全部生成
"""
def func():
    for i in range(9999):
        yield i
gen = func()#生成器记录步骤和代码
print(gen.__next__())
print(gen.__next__())
"""
0
1
"""

生成器表达式推导式

"""
推导式

"""
# 普通写法
lst = []
for i in range(1, 5):
    s = f"乡村爱情{i}"
    lst.append(s)
print(lst)  # ['乡村爱情1', '乡村爱情2', '乡村爱情3', '乡村爱情4']
# 列表推导式写法 一行搞定
lst = [f"乡村爱情{i}" for i in range(1, 5)]
print(lst)  # ['乡村爱情1', '乡村爱情2', '乡村爱情3', '乡村爱情4']

# 求10以内被2整除的数
inn = [i for i in range(1, 10) if i % 2 == 0]
print(inn)  # [2, 4, 6, 8]

# 找出姓张的同学，并把张 改为王
zz = ["张无忌", "张三丰", "李夏怡", "赵铭"]
su = [name.replace("张", "王") for name in zz if name.startswith("张")]
print(su)  # ['王无忌', '王三丰']

# 字典推导式
lst = [11, 22, 33]
dic = {i: lst[i] for i in range(len(lst))}
print(dic)  # {0: 11, 1: 22, 2: 33}

# 集合
lstt = [11, 22, 33]
dic = {lstt[i] for i in range(len(lstt))}
print(dic)  # {33, 11, 22}

#没有元组推导式

常用函数

时间相关

import time
print("******")
time.sleep(5)#休息5秒
print("------")

#打印当前时间 格式是：2024-02-18 09:38:17
import datetime
print(datetime.datetime.now().strftime("%Y-%m-%d %X"))

异常

基本异常

n = input("请输入被除数: ")
m = input("请输入除数: ")
if n.isdigit() and m.isdigit(): #是否是0
    if m != "0":
        res = float(n)/float(m)
        print("res:",res)
    else:
        print("除数不能为0")
else:
    print("请输入数字")
print("程序继续运行并正常结束")


#捕获异常
try:
    n = input("请输入被除数: ")
    m = input("请输入除数: ")
    res = float(n)/float(m)
    print("res:",res) #如果报错，这句代码不会执行
except:
    print("出错了")
print("程序继续运行并正常结束")

#指定要捕获的异常类型
try:
    n = input("请输入被除数: ")
    m = input("请输入除数: ")
    res = float(n)/float(m)
    print("res:",res) #如果报错，这句代码不会执行
except ValueError:
    print("请输入数字") #数字错误
except ZeroDivisionError:
    print("除数不能为0") #除0错误
except BaseException:
    print("出错了") #所有错误类型
    
#指定要捕获的异常类型 写法2
try:
    n = input("请输入被除数: ")
    m = input("请输入除数: ")
    res = float(n)/float(m)
except ValueError:
    print("请输入数字") #数字错误
except ZeroDivisionError:
    print("除数不能为0") #除0错误
except BaseException:
    print("出错了") #所有错误类型
else:
    print("res:",res)
finally: #不管有没有错，都会执行
    print("用户计算完毕，计算结束")

嵌套的异常处理


try:
    f = open("w.txt")
    for line in f:
        3/0
        print(line,end="")
except ZeroDivisionError:
    print("除数不能为0")
finally:
    if f: #如果f存在就执行下面的
        f.close()

try:
    f = open("w.txt")
    for line in f:
        try: #这样做 虽然有错误，但是不影响正常的文件读取
            3/0
        except ZeroDivisionError:
            print("计算错误")
        print(line,end="")
except ZeroDivisionError:
    print("除数不能为0")
finally:
    if f: #如果f存在就执行下面的
        f.close()

with 上下文管理

#with 上下文管理
#省略f.close()代码，实现自动关闭
with open("w.txt","r",encoding="gbk") as f: #f等于 f = open("w.txt")
    for line in f:
        print(line,end="")

图片复制

#图片复制
with open("wallhaven-z8jl7w.jpg","rb") as fin: #读取一个图片，存在的
    with open("wallhaven-z8jl7w-2.jpg","wb") as fout: #新建一个图片
        for data in fin:#循环已在的图片数据
            fout.write(data)##循环已在的图片数据,然后写入

#图片复制,同时打开两个文件
with open("wallhaven-z8jl7w.jpg","rb") as fin,open("wallhaven-z8jl7w-3.jpg","wb") as fout:
    for data in fin:#循环已在的图片数据
        fout.write(data)##循环已在的图片数据,然后写入

debug

图片[12]-python基础-秋风落叶

导入模块

#导入模块也可以起别名
import mymou as m

if __name__ == '__main__':
 把脚本变量写在这下面 ,函数可以写在之外   

方式2：把变量写在一个函数中，然后再引用
def main():
    a = 10
    print(a)
if __name__ == '__main__':
    main()
#添加新的路径    
import sys
print(sys.path)
sys.path.append("d:\lib\haha")

#查看内置模块名称
import sys
print(sys.builtin_module_names)

import os
print(__file__)
D:\Users\Administrator\PycharmProjects\pythonProject\demowenjian.py

import os
print(__file__)
#获取不同操作系统的路径
print(os.path.dirname(__file__))
D:\Users\Administrator\PycharmProjects\pythonProject\demowenjian.py
D:\Users\Administrator\PycharmProjects\pythonProject

import sys
import os
print(os.path.dirname(__file__) + r"/lib")
sys.path.append(os.path.dirname(__file__) + r"/lib")
print(sys.path)

D:\Users\Administrator\PycharmProjects\pythonProject/lib
['D:\\Users\\Administrator\\PycharmProjects\\pythonProject', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310\\python310.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python310', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject\\venv', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject\\venv\\lib\\site-packages', 'D:\\Users\\Administrator\\PycharmProjects\\pythonProject/lib']

#直接引用函数 08是模块名  ipaddress是函数名称
from day08 import ipaddress
print(ipaddress)

#直接引用所有函数 有弊端
from day08 import *

#还能起别名
from day08 import ipaddress as ip

© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
语言
# 开发语言
喜欢就支持一下吧
点赞7 分享
istudy的头像-秋风落叶
apache httpd-秋风落叶
apache httpd
apache httpd
3年前 5909
devOps-秋风落叶
devOps
devOps
3年前 5886
mysql安装部署手册-秋风落叶
mysql安装部署手册
mysql安装部署手册
3年前 4423
nginx安装部署-秋风落叶
nginx安装部署
nginx安装部署
3年前 4280
ShellScript-秋风落叶
ShellScript
ShellScript
3年前 4268
weblogic-秋风落叶
weblogic
weblogic
2年前 4260
相关推荐
html-秋风落叶
html
html
2年前 2984
css-秋风落叶
css
css
2年前 2860
python基础-秋风落叶
python基础
python基础
1年前 151
python爬虫-秋风落叶
python爬虫
python爬虫
12个月前 106
评论 抢沙发
头像
欢迎您留下宝贵的见解！
提交
头像

昵称

取消
昵称

请填写用户信息：

  • 昵称(必填)
  • 邮箱(必填)
表情
[aoman][baiyan][bishi][bizui][cahan][ciya][dabing][daku][deyi][doge][fadai][fanu][fendou][ganga][guzhang][haixiu][hanxiao][zuohengheng][zhuakuang][zhouma][zhemo][zhayanjian][zaijian][yun][youhengheng][yiwen][yinxian][xu][xieyanxiao][xiaoku][xiaojiujie][xia][wunai][wozuimei][weixiao][weiqu][tuosai][tu][touxiao][tiaopi][shui][se][saorao][qiudale][qinqin][qiaoda][piezui][penxue][nanguo][liulei][liuhan][lenghan][leiben][kun][kuaikule][ku][koubi][kelian][keai][jingya][jingxi][jingkong][jie][huaixiao][haqian][aini][OK][qiang][quantou][shengli][woshou][gouyin][baoquan][aixin][bangbangtang][xiaoyanger][xigua][hexie][pijiu][lanqiu][juhua][hecai][haobang][caidao][baojin][chi][dan][kulou][shuai][shouqiang][yangtuo][youling]
代码

请输入代码：

确认
图片
快捷回复
谢谢你的分享，我从中学到了很多！
教程很好用，谢谢！
好东西，学习一下！
楼主听话，快到碗里来！
路过一下，我只是来打酱油的！
水帖美如花，养护靠大家！

    暂无评论内容