python语法
Posted wp950416
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python语法相关的知识,希望对你有一定的参考价值。
Python
-
常见的DOS命令
- dir 查看目录
- cd 进入指定的目录
- md 目录名 创建目录
- rm 目录名 删除目录
- del 文件名(包括后缀) 删除文件
-
文本文件和字符集
- 文本分为纯文本跟富文本
- 开发时,使用的都是纯文本
- 字符集 utf-8(万国码,几乎通用),一般出现乱码就是字符集的问题
-
编译型语言和解释型语言
- c语言(编译型语言) 会在代码执行前将代码编译成机器码,再交给计算机执行,特点:执行快,跨平台型差
- Python、JS、Java(解释型语言) 不会再代码执行前编译,而是边执行边编译 特点:执行慢,跨平台型好
-
Python的用途(排名tiobe)
-
web应用
- 豆瓣
-
爬虫程序
-
科学计算
-
自动化运维
-
大数据
-
云计算
-
人工智能
-
桌面软件/游戏等
-
-
Python(anaconda navigator)结合pycharm
-
pyCharm创建项目→create project→需要选择project interpreter(exciting interpreter选择python.exe)
-
Python的基本语法
- 在Python中严格区分大小写
- Python的每一行就是一条语句,每条语句以换行结束.
- 一条语句可以分多行编写,多行编写时语句后边以结尾
- Python是缩进严格的语言,所以在Python中不要随便写缩进
- 在Python中使用#表示注释,习惯上#后面跟一个空格,‘‘‘表示多行注释
- Python中使用变量不需要申明,直接变量赋值
- Python不能使用没有进行赋值的变量
- Python可以为变量赋任意的值,也可以任意修改变量的值
-
-
pyCharm的常用快捷键
- Ctrl + Alt + L 代码格式化
- Shift + Enter 另起一行
- Ctrl + Shift + R 全局替换
- Ctrl + Shift + F 全局查找
- Shift + F10 运行
- Shift + F9 调试
-
字面量和变量、标识符
-
number值、String值都可以作为字面量
-
变量用于保存字面量
-
标识符(自主命名的内容都属于标识符)
- 变量名、函数名、类名都属于标识符
- 标识符可以含有字母、数字、_,但是不能以数字开头
- 标识符不可以使用关键字和保留字
-
-
命名规则
- 所有字母小写
- 单词与单词之间,首字母小写,其他单词首字母大小. 例:studentName
- 还有一种使用单词与单词之间使用下划线
-
数值
-
在Python中数值分为三种:整数、浮点数、复数
-
在Python中所有的整数都是int类型
-
如果数字的长度过大,可以使用下划线_作为分隔符
-
十进制的数值不能以0开头
-
对浮点数进行计算的时候,可能会得到一个不精确的值.比如:
c=0.1+0.2 print(c)
-
-
可以通过在字符串前添加一个f来创建一个格式化字符串,在格式化字符串中可以直接嵌入变量
a="abc" b=124 c=f"hello {a},{b}" print(c) # 该输出呈现的是字符串 print(f"a={a},b={b}")
-
可以通过.format格式化输出,在格式化字输出中可以直接嵌入变量
a="name" b=123 print("a={},b={}" .format(a,b))
-
布尔型 bool 只能装(True/False)
- 布尔值主要用来做判断
- 布尔值实际上也属于整型,可用来跟number进行运算,True=1,False=0
-
序列的分类
-
可变序列
- 列表 可变可重复
- 集合 可变不可重复
-
不可变序列
- 字符串
- 元祖
-
-
列表 list [1,2,3,4...]
# 按照下标获取列表中的字段 nameList = ["王大锤", "唐马儒", "鹿晗", "蔡徐坤", "李现"] print(nameList[2]) # 列表可以保存不同类型的元素 a = ["abcd", 11, True] # len() 获取列表的长度 l = len(nameList) print(l) # 表示从后向前获取元素,获取2个元素,-1表示倒数第一个 print(nameList.stus[-2]) # 表示获取元素(包括起始位置,不包括结束位置),stus函数在做切片操作时,总会返回一个新的列表,不会影响原来的列表 print(nameList.stus[1:4]) # 如果省略结束为值,则会一直截取到最后,同理如果省略开始位置,则会从第一个元素开始截取 print(nameList.stus[1:]) # 表示从开头位置截取到第5个位置,并且是每下两个截取一个(通俗的讲就是隔一个截取) print(nameList.stus[1:5:2]) # 将两个列表拼成一个列表 lists=[1,2,3]+[4,5,6] # 可以重复列表(表示123123) lists=[1,2,3]*2 # min()获取列表中的最小值 # max()获取列表中的最大值 #获取列表指定元素在列表中的位置 print(nameList.index("王大锤")) # 查找列表中指定元素 ,第二个参数表示查找的起始位置(包括开始,但是如果第三个刚好是查找的元素,则忽略),第三个参数表示查找的结束位置(不包括) print(nameList.index("王大锤",3)) # 查找元素在列表中出现的次数 print(nameList.count("王大锤")) # 使用循环遍历列表,这里的i表示下标,range里面表示列表的长度 for i in range(len(nameList)): print(nameList[i]) # 此种遍历列表的方式,name表示的集合中可变的值(集合长度决定该值的个数),nameList是一个集合 for name in nameList: print(name) # append() 向列表中添加元素,不需要返回值 nameList.append("渣渣辉") for name in nameList: print(name, end=‘ ‘) # extend() 将一个列表添加到另一个列表中,并且是加入到另一个列表的末尾位置 nameList2 = ["吴亦凡", "周杰伦", "古天乐"] nameList.extend(nameList2) print(nameList) # insert() 在指定的位置前插入元素 nameList.insert(1, "东尼大木") print(nameList) # 修改元素,需要通过下标来修改 nameList[0] = "张全蛋" print(nameList) # in 判断 指定的元素是否被包含在列表中,包含就返回true,不包含就返回false print("jack" in nameList) # not in 判断指定元素是否被包含在列表中,不包含返回true,包含了返回false print("jack" not in nameList) # 删除列表中元素,根据下标进行删除 del nameList[0] print(nameList) # pop()函数,删除最后一个元素,括号内如果加上参数的话,跟del功能就类似,负值表示倒数,正值表示正数 nameList.pop() print(nameList) # remove() 根据指定的元素来删除,完全匹配 nameList.remove("吴亦凡") print(nameList) # sort排序 number = [] for i in range(10): number.append(random.randint(0, 100)) number.sort() # reverse=True,由大到小排列 number.sort(reverse=True) print(number) # reverse() 也可以作为函数使用,表示反转列表 nameList.reverse()
-
列表的嵌套
a = [[1, 2, 3], [11, 22, 33], [33, 66, 99]] print(a[0]) print(a[1]) print(a[2][2])
-
集合
# 使用{}来粗创建集合,集合的顺序是由python解释器自己去排列的 # 通过set可以将序列和字典转换为集合 # 使用set()函数将字典转换为集合的时候,只会包含字典的键 # 使用len()函数获取集合中元素的数量 # 使用add()函数可以向集合中添加元素 # 使用update()函数将另一个集合添加到当前集合中 # 使用pop()函数随机删除集合中的一个元素 # 使用remove()删除指定的元素name print(info.remove(name)) # 使用clear()函数清空集合 # 使用copy()函数对集合进行浅复制
-
集合的运算
# 对集合做运算时,不会影响原来的集合,而是将运算结果返回 # &交集运算 s={1,2,3} s2={3} result=s & s2 print(result) 输出3 # |并集运算 表示合并集合 # -差集运算 表示返回减号前面有的,后面没有的值 # ^亦或集运算 表示返回两个集合中除了共有的值 # <=检查一个集合是否是另一个集合的子集,意思就是当前集合中的元素是否全部在另一个集合中出现,那么当前的集合就是另一个集合的子集
-
字符串
-
在Python中字符串需要使用引号引起来,相同的引号不能嵌套使用
-
单双引号不能跨行使用,需要使用来进行连接
-
使用三重引号来表示一个长字符串,并且三重引号可以换行,会保留字符串中的格式.
-
字符串也可以进行加法运算,作为拼接
-
变量中存放字符串,如果使用*表示复制 例:a="abc" c=a * 3 print(c)
-
%3.5s表示3-5个字符(多个截去,少了补空格)
-
"hello %4s"%123 可以以数字作为占位符
-
"hello %4s"%123.34 也可以以浮点数作为占位符
-
"hello %4fs"%234.4 以浮点数作为占位符,并且小数保留4位
-
"hello %4ds"%234.4 整数占位符
# %s表示指定一个占位符,单独的s表示任意字符 b="hello %s"%"world" print(b) # %s指定的占位符可以容纳多个字符,字符间用逗号隔开 c="hello %s say %s"%("world","goodbye") print(c) # %3s表示限制占位3位,如果不够空格补充,超过则保留3位 d="hello %3s"%"world" print(d)
-
-
字符串常用函数
str="thinking in python" print(str.find("in")) # find() 在指定的范围查找,包含开始不包含结束 print(str.find("in",0,4)) # count() 检测指定字符串,在字符串中出现的次数 print(str.count("in")) # replace() 替换操作,将字符串中的内容,替换成新的内容 print(str.replace("python","C++")) print(str.replace("in","out")) # split() 分割操作,按照指定的内容,将字符串分割 print(str.split("i")) a="good good study day day up" print(a.split(" ")) # capitalize() 把字符串第一个字符改成大写的 print(str.capitalize()) # title() 将字符串每个单词的首字母改成大写 print(str.title()) # startwith() 检测字符串是否以指定的内容开头,是则返回True,否则返回False print(str.startswith("think")) # endswith() 检测字符串是否以指定内容结尾,是返回True,否则返回False print(str.endswith("on")) # lstrip() 去除字符串左边的空格 a=" asdw " print(a.lstrip()) # rstrip() 去除字符串右边的空格 print(a.rstrip()) # strip() 去除字符串两边的空格 print(a.strip()) # isalpha() 判断字符串中是字母返回True,不是就返回False str2 = "abc123" print(str2.isalpha()) # isdigit() 判断字符串中全部是数字字符返回True,不是返回False str3 = "123456789" print(str3.isdigit()) # isspace() 判断字符串中只包含空格返回True,不包含就返回False str4=" " print(str4.isspace())
-
字符串的下标应用
-
下标
s="abcdef123啊啊啊" # 根据下标为0,获取字符串中第一个字符 print(s[0]) print(s[6])
-
截取字符串 s[a,b]
strs="sdfsaf" # 做截取操作时,包含开始,不包含结束 print(s[0:3]) # 从指定位置截取到字符串末尾 print(s[3:]) # 表示截取倒数第二个字符,-2表示倒数第三个字符,以此类推 print(s[0:-1])
-
-
元祖
- 操作方式基本和列表类似
- 不同的是,元祖的元素不能修改元祖使用小括号
- 一般我们希望数据不被改变时,就可以使用元祖,其余情况偶读使用列表
- 两个值交换,可以利用元祖的解包 a,b=b,a
-
判断数据类型 type(变量名)
-
函数
-
input() 实现输入
-
sum() 求和
a=123 b=345 # sum里面第一个参数表示列表(相加),第二个表示相加的数 c=sum([11,2],(4)) print(c)
-
range(start,stop,step)
-
用途 用来生成一个自然数的序列
-
三个参数的含义
- start 表示开始位置(包含)
- stop 表示结束位置(不包含)
- step 表示步数(默认自增1)
-
一般通过range()函数创建一个执行指定次数的for循环
-
-
-
自定义函数
-
语法:def 函数的名称():
-
调用方式:函数名()
-
自定义函数的四种定义方法
- 无参数,无返回值.若函数内没有print输出,那么调用该函数,则为空内容.
- 无参数,有返回值.创建一个变量接受函数内返回的值(需要return),那么调用该函数,输入的是返回的内容.
- 有参数,没有返回值.
- 有参数,有返回值.
# 创建函数的时候,也可以定义默认形参,如果用户传递了参数则默认值没有任何作用;如果用户没有传递,那么默认值就会生效 def info(name="吴鹏",age=19): print(name,age) info() # 在定义函数时,可以在形参前边加上一个*,这样这个形参将会获取到所有的实参,它会将所有的实参保存到一个元祖中,如下:*a会接受所有的位置实参,并且将这些实参统一保存到一个元祖中 def fn(*a): print("a={}" .format(a),type(a)) fn(1,2,3,4,5,6) # 定义一个函数,可以求任意个数字的和 # 带*号的参数只能是一个,如果带*号的在形参的中间,那么后面的形参相对应的实参必须要有赋值的形式进行传递 def sum(*a): result=0 for fn in a: result+=fn print(result) sum(10,20,30,40) # 参数的解包,*t会自动将序列中的元素默认作为参数传递,要求序列中元素的个数必须和形参的个数一致 def fn4(a,b,c): print(a) print(b) print(c) # 使用列表 t=(10,20,30) fn4(*t) # 使用字典 **d的功能跟上面的类似 d={"a":100,"b":200,"c":300} fn4(**d)
-
-
返回值
- return后边跟什么值,函数就会返回什么值
- return后边可以跟任意的对象,返回值甚至可以是一个函数
- 如果仅仅写一个return或者不写return,则相当于return None
- 在函数中,return后的代码都不会执行,return一旦执行函数自动结束
-
数据类型转换
-
转成整型 int()
- bool值 True会转成1,False会转成0
- 浮点数会直接转成整数
- 合法的整数字符串会转换成int类型,如果不是一个合法的,那么将会报错
-
转成浮点 float() 转换过程跟int类似,不同的是,小数点会用0代替
-
转成字符串 str()
-
转成bool值 bool()
- 任何对象都可以转换成bool值
- 对于所有表示空性的对象都会转换为False,其余的转换为True
-
-
算数运算符
- 对于字符串相加,就是将两个字符串拼接在一起
- 如果数字跟bool值进行加减法运算时,会先将bool值转换为number在进行运算
- 字符串和数值是不能相加.
- ** 幂运算
- /表示除号 //表示整除
- % 取余
-
转义字符
- ‘ 表示 ‘
- " 表示 "
- t 表示制表符
- n 表示换行符
- 表示反斜杠
- uxxxx 表示unicode编码
-
关系运算符 <,>,==,!==,<=,>=
- 关系运算返回结果是bool类型,只能返回True/False
- 数值类型和字符串类型不能比较
- 当对字符串进行比较时,实际上比的是字符串的unicode编码
- 如果需要对数字型字符串作比较的话,需要先转换为number
- is 比较两个对象是否是同一个对象,比较的是对象的id
- is not 比较两个对象是否不是同一个对象,比较的是对象的id
-
逻辑运算(and,or,not)
- 逻辑运算结果,只能是bool型,返回值True/False
- 当and(&)两边运算结果为True时,最终结果为True,否则为False
- 当or 左右两边的运算结果都为False的时候,最终结果为False,否则结果就是True
- not逻辑非是取反
-
分支结构
-
if
- if...else
- if...elif...else
-
闰年的规则:
- 年份取余4等于0
- 年份取余100不等于0
- 年份取余400等于0
-
-
循环结构
- while
-
for...in... 1. in后面跟的是序列 2. in后面也可以是一个字符串 3. in后也可以是range()函数
-
模块的引入
-
random
- 引入random→import random
- random randint(0,100) 0-100的随机数
-
从另一个文件中引入函数(如果引入所有使用*)
-
-
python的相关练习
# 计算所有的奇数之和(使用while) num = 0 sum = 0 while num <= 100: if num % 2 != 0: print(num) sum += num num += 1 print("所有奇数和:{}".format(sum))
# 计算所有的奇数之和(使用for...in...) sum = 0 # 与while的区别:num不需要定义变量为0 for num in range(101): if num % 2 != 0: print(num) sum += num num += 1 print("所有的奇数之和:{}".format(sum))
# 使用for动态打印矩形 # 外层循环控制行,内层循环控制列 num=input("请输入边数:") num=int(num) for i in range(num-1): for j in range(num): print("*",end="") print("")
# 动态打印正三角 num = input("请输入三角的边数:") num = int(num) for i in range(num): for j in range(i + 1): print("*", end="") print("")
# 乘法表 # 1*1=1 # 1*2=2 2*2=4 # 1*3=3 2*3=6 3*3=9 num = int(input("请输入乘法表边数(行跟列)")) for i in range(num + 1): for j in range(i + 1): print("{}*{}={}".format(j + 1, i + 1, (j + 1) * (i + 1)), end=" ") print("")
# 电脑随机一个0-100的数,将用户输入的跟电脑随机的数字对比,满分是100分,猜错口扣10分,分数为0,停止程序. import random score = 100 # randint(0,100) 包含0跟100 a = random.randint(0, 100) count = 0 while True: num = int(input("请输入第{}个:".format(count + 1))) if num > a: print("猜大了") elif num < a: print("猜小了") else: print("猜对了") count += 1 if count == score / 10: break print("分已经全没,重启程序")
‘‘‘ 猜数字游戏,电脑随机产生一个0-100的整数,用户在控制台输入一个整数,将用户输入的和电脑产生的进行对比: 如果用户猜大了,就提示猜大了,猜小了,就提示猜小了,猜对了就恭喜答对了 满分是100分,猜错一次就减10分, 当分数为0的时候,停止程序。 ‘‘‘ import random content = random.randint(0, 100) count = 0 score = 100 while True: if score == 0: print("您的分数已经归为0,再见") break num = int(input("请输入第{}个数:".format(count + 1))) if num > content: print("您猜大了") score -= 10 print("当前分数为:{}".format(score)) elif num < content: print("您猜小了") score -= 10 print("当前分数为:{}".format(score)) else: print("恭喜你,猜对了,当前分数为:{}".format(score)) break count += 1
‘‘‘ 随机加减乘除运算,一共出10题,电脑随机产生2个0-100的整数,进行随机加减乘除法计算 然后用户输入计算结果,判断用户输入的是否正确,回答正确就加十分,错误就不加分,10题全对就是100分 ‘‘‘ import random score = 0 test = 0 sum = 0 while True: if test == 10: break num1 = random.randint(0, 100) num2 = random.randint(0, 100) t = random.randint(0, 3) if t == 0: print("请回答第{}题:{}+{}=?".format((test + 1), num1, num2)) sum = num1 + num2 elif t == 1: print("请回答第{}题:{}-{}=?".format((test + 1), num1, num2)) sum = num1 - num2 elif t == 2: print("请回答第{}题:{}*{}=?".format((test + 1), num1, num2)) sum = num1 * num2 else: print("请回答第{}题:{}//{}=?".format((test + 1), num1, num2)) sum = num1 // num2 user = int(input("请输入结果:")) if user == sum: score += 10 print("回答正确加10分,当前分数为:{}".format(score)) else: print("回答错误减10分,当前分数为:{}".format(score)) print("当前总分为:{}".format(score)) test += 1
-
循环、列表等混合练习
‘‘‘ 创建一个10个长度整数列表,列表中的10个元素,使用随机数赋值,范围0-100,然后找出列表中的最大值 ‘‘‘ import random list = [] for i in range(10): list.append(random.randint(0, 100)) for j in range(len(list)): max = list[0] if max < list[j]: max = list[j] print(list[i], end=" ") print("最大值为:{}".format(max))
# 冒泡排序 num = [51, 12, 55, 29, 18, 18, 18, 18, 55, 295, 5, 29] for i in range(len(num)): # 选出最大去掉一个 for j in range(len(num) - 1 - i): if num[j] > num[j + 1]: t = num[j] num[j] = num[j + 1] num[j + 1] = t print(num)
‘‘‘ 从26个字母中,随机选出4个不重复的字母 并且把4个字母,添加到一个列表中 用户在控制台输入4个字母,将用户输入的也添加到一个列表中 然后将电脑的和用户的 进行对比 ‘‘‘ import random # 从26个字母中,随机选出4个不重复的字母 def getChar(): c1 = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘, ‘m‘, ‘n‘, ‘o‘, ‘p‘, ‘q‘, ‘r‘, ‘s‘, ‘t‘, ‘u‘, ‘v‘, ‘w‘, ‘x‘, ‘y‘, ‘z‘] c2 = [] for i in range(4): index = random.randint(0, len(c1) - 1) c2.append(c1[index]) del c1[index] print(c2) return c2 # 检查用户输入是否正确的 def check(charList, user): # 第一个下标保存猜对了几个, # 第二个下标保存位置对了几个 result = [0, 0] for i in range(len(charList)): if user[i] in charList: result[0] += 1 if user[i] == charList[i]: result[1] += 1 print("猜对了{}个,位置对了{}个。".format(result[0], result[1])) return result print("猜字母游戏开始了。") charList = getChar() while True: str = input("请输入四个字母,退出输入exit") if str == "exit": break user = [] for s in range(4): user.append(str[s]) print(user) res = check(charList, user) if res[1] == 4: print("恭喜,全部猜对了") break print("游戏结束")
-
作用域
-
全局作用域
- 在程序执行时创建,在程序执行结束时销毁
- 所有函数以外的区域都是全局作用域
- 在全局作用域中定义的变量,都属于全局变量,全局变量可以在程序的任意位置被访问
-
函数作用域
- 函数作用域在函数调用时创建,在调用结束后销毁
- 在函数作用域定义的变量,都是局部变量,只能在函数内部访问
-
变量的查找 当使用变量时,会优先在当前作用域中寻找该变量,如果有则使用如果没有则继续去上一级作用域中寻找,如果有则使用,直到找到全局作用域,依然没有找到,则会抛出异常.
-
如果希望在函数内部修改全局变量,则需要使用global关键字,来声明变量,声明多个使用逗号隔开
# 全局变量 allIn=99 name="吴鹏" age=24 def userInfo(): age=18 # 全局变量可以在函数中被访问,但是如果你想在函数中修改全局变量,那么就需要用 global进行修饰 global allIn,name allIn+=1 name="吴磊" print("姓名:{},年龄:{},allIn:{}".format(name,age,allIn)) def thanme(): print(allIn) def show(): print("姓名:{},年龄:{},allIn:{}".format(name, age, allIn)) userInfo() thanme() show()
-
-
命名空间
- 命名空间指的是变量存储的位置,每一个变量都需要存储到指定的命名空间当中
- 每一个作用域都会有一个对应的命名空间
- 全局命名空间,用来保存全局变量,函数命名空间用来保存函数中的变量
- 命名空间实际上就是一个字典,是一个专门用来存储变量的字典
- 如果在全局作用域中调用locals()则获取全局命名空间,如果在函数作用域中调用local()则获取函数命名空间
-
字典
-
字典和列表类似,也是永爱保存一堆数据
-
语法:变量名={"键名1":"值1","键名2":"值2"}
-
需要注意的是键名也是要用引号包起来
-
字典中的键名是不能重复的
-
修改键值 变量名["键名"]="新键值"
-
删除键值对 del 变量名["键名"]
-
删除字典中的内容,不删除字段 变量名.clear()
-
直接删除整个字典 del 变量名
-
获取字典中所有的key与value 变量名.key() 变量名.value()
info={"name":"吴鹏","age":12} # 获取其中的键值,需要使用get方法,如果不存在,将会返回none print(info.get("name")) # 也可使用采用类似于下标的方法得到键值,但是在使用变量赋的键名,不能使用引号 print(info["name"]) # 可以使用dict()函数创建字典 d=dict{"name":"吴磊","age":24} # 修改键值 info["name"]="吴磊" print(info.get("name")) # 如果修改键值,该键名不存在,那么就是添加的操作 info["adress"]="南京市" print(info) # 使用setdefault()函数,可以向字典中添加键值对.如果说存在键,那么就会返回key的值,不会对字典做任何操作 info.setdefault("adress":"南京市") # 使用update()函数,将其他字典添加到当前的字典中 a={"name":"abc",age=11} b={{"adress":"南京",classes=11}} # 将b中的键值对添加到a的字典中,如果有重复的,后面的会将前面的替换掉 a.update(b) # 删除键值对 del info["adress"] print(info) # 使用popitem()函数,随机删除字典中的一个键值对,一般都会删除最后一个键值对,删除之后,会将删除的key-value作为返回值返回,返回的是一个元素,第一个元素是删除的key,第二个删除的是value print(info.popitem()) # 删除字典中的内容,不删除字典 # info.clear() # print(info) # 直接删除整个字典 # del info print(info.keys()) print(info.values()) # copy()函数,复制,好处就是复制以后的对象和源对象是独立的,修改一个不会影响另一个 d1={"name":"ad","age":10} d2=d1.copy() # 获取字典键值对的个数 print(len(info)) # in检查字典中是否包含指定的键 # not in 检查字典中是否不包含指定的键 #遍历字典 for k in d.keys(): print(k,d[k])
-
-
文件操作
-
文件操作的语法 变量名=open("文件名称",打开方式,定义字符集)
- 打开方式 r:读取 w:写入,创建,覆盖 a:写入,创建,追加
- 字符集:encoding=utf-8
-
每操作一次文件,必须要关闭 变量.close()
-
判断文件是否是关闭 变量.closed
-
写入内容 变量.write()
-
读取文件内容 变量.read()
-
文件改名,需要引入模块os os.rename("原始文件名","新文件名")
-
删除文件 同样需要引入模块 os.remove("文件名")
‘‘‘ 文件操作 f = open(‘文件名称‘,‘打开方式‘) r : 读取, w :写入,创建,覆盖 a : 写入,创建,追加 ‘‘‘ f = open(‘a.txt‘,‘w‘) # 获取文件名称 print(f.name) # 获取打开方式 print(f.mode) # 判断文件是否关闭,关闭True, 没有关闭false print(f.closed) # close()函数,是用来关闭文件, 文件打开使用完之后,一定要记得关闭 f.close() print(f.closed) f = open("a.txt","w") # write()写入字符串 f.write("1234567890") # 操作完要记得关闭 f.close() f = open("a.txt","w") f.write("我的贱就是你的贱") f.close() f = open("a.txt","w",encoding=‘utf-8‘) f.write("good good") f.close() # 追加内容操作 f = open("a.txt","a",encoding=‘utf-8‘) f.write("艾斯帝王企鹅") f.close() f = open("a.txt","a",encoding=‘utf-8‘) f.write(" ") f.write("面朝大海,春暖花开") f.close() # 读取文件内容 f = open("a.txt",‘r‘,encoding=‘utf-8‘) s1 = f.read() # 要记得关闭文件 f.close() # 改名操作需要引入模块 import os # os.rename("a.txt","b.txt") # 删除文件,remove() os.remove("a.txt") # 在with语句中可以直接使用对象来做文件操作 with open("a.txt",‘r‘,encoding=‘utf-8‘) as f: #此时文件只能在with中使用,一旦with结束则文件会自动close() print(f.read()) # 读取文件中的一行内容 with open(‘a.txy‘,encoding=‘utf-8‘) as f: print(f.readline()) # readlines()这个方法用于一行一行的读取内容,它会一次性将读取到的内容封装到一个列表中返回 # 使用with as写入文件 with open(‘a.txt‘,‘w‘,encoding=‘utf-8‘) as f: f.write(‘youname‘) # r表示只读 # w表示可写 # a表示追加 # +表示操作符增加功能 # x用来新建文件,如果文件包不存在则创建,存在则报错 # r+表示可读与可写,文件不存在会报错 # seek()方法可以修改当前读取的位置 f.seek() # tell()方法用来查看当前读取的位置 f.tell()
-
-
对象
-
每个对象都要保存三种数据 id type value
- id id用来表示对象的唯一性,可以通过id()函数来查看对象的id,id是由解析器生成,一旦创建,它的id永远不能改变
- type 用来标识当前对象所属的类型,比如:int str float等
- value 就是对象中存储的具体的数据
-
对象在python中,变量中存储的不是对象的值,而是对象的id(内存地址),当我们使用变量时,实际上就是通过对象id在查找对象.
-
-
==和is
- 当a的列表跟b的列表相同时,使用==会返回True.比较的是值
- 当a的列表跟b的列表相同时,使用is会返回False.比较的是对象,内存地址值不同
-
文档字符串
-
help() 是python中的内置函数,通过help()函数可以查询python中函数的用法
-
文档字符串只需要在函数的第一行写一个字符串就是文档字符串,该字符串使用‘‘‘引一下,最终使用help()函数传入函数名
def fn(a:int,b:bool): ‘‘‘ 这是一个文档声明 a的作用传入int类型的值 b的作用传入一个bool类型的值 ‘‘‘ help(fn)
-
-
递归
-
简单的理解递归,就是循环自己一直,自己引用自己.
-
递归式函数的两个条件:
- 基线条件 问题可以被分解为最小问题,当满足基线条件时,递归就不在执行了.
- 递归条件 将问题继续分解的条件
# 求10的阶乘(1*2*3*4*5*...*10) # 10!=10*9! # 9!=9*8! # 8!=8*7! # ... # 1!=1 def factorial(n): # 该函数用来求任意数的阶乘 # 基线条件,判断n是否为1,如果为1则此时不能再继续进行递归 if n==1: # 1的阶乘就是1,直接返回1 return 1 return n*factorial(n-1) print(factorial())
-
-
递归的练习
# 创建一个函数 power 来为任意数字做幂运算 n ** i # 10 ** 5 = 10 * 10 ** 4 # 10 ** 4 = 10 * 10 ** 3 # ... # 10 ** 1 = 10 def power(n , i): ‘‘‘ power()用来为任意的数字做幂运算 参数: n 要做幂运算的数字 i 做幂运算的次数 ‘‘‘ # 基线条件 if i == 1: # 求1次幂 return n # 递归条件 return n * power(n , i-1) # print(power(8,6))
# 检查指定的字符串是不是回文字符串 def hui_wen(s): ‘‘‘ 该函数用来检查指定的字符串是否回文字符串,如果是返回True,否则返回False 参数: s:就是要检查的字符串 ‘‘‘ # 基线条件 if len(s) < 2 : # 字符串的长度小于2,则字符串一定是回文 return True elif s[0] != s[-1]: # 第一个字符和最后一个字符不相等,不是回文字符串 return False # 递归条件 return hui_wen(s[1:-1]) print(hui_wen(‘abcdefgfedcba‘))
-
函数式编程 在python中,函数时一等对象,有如下几个特点:
- 对象是在运行时创建
-
能赋值给变量或作为数据结构中的元素
- 能作为参数传递
-
能作为返回值返回
-
高阶函数 至少符合以下两个特点中的一个:
- 接收一个或多个函数作为参数
- 将函数作为返回值返回
-
匿名函数
-
lambda函数表达式专门用来创建一些简单的函数,他是函数创建的又一种方式
-
匿名函数一般都是作为参数使用,其他地方一般不会使用
-
语法:lambda 参数列表 : 返回值
def fn(a,b): return a+b # 等同于如下的匿名函数 fn2=lambda a,b : a + b # 一般不会这么做
-
map()函数可以滴可迭代对象中的所有元素做指定的操作,然后将其添加到一个新的对象中返回
l=[1,2,3,4,5] r=map(lambda i:i+1,l) print(list(r))
-
sort()函数
-
该方法用来对列表中的元素进行排序
-
sort方法默认是直接比较列表中元素的大小
-
在sort()可以接受一个关键字参数key,它需要一个函数作为参数,当设置了函数作为参数,每次都会以列表中的一个元素作为参数来调用函数,并且使用函数的返回值来比较元素的大小
# 字符串默认按照unicode编码排序 l=["a","b","cc","aa"] # 使用key=len是按照字符串的长度排序 l.sort(key=len) print(l) # 直接排序会报错 m=[1,2,"3",2,"3"] # 使用key=int 会暂时转化为int类型排序 m.sort(key=int) print(m)
-
-
sorted()
- 这个函数和sort()的用法基本一致,但是sorted()可以对任意的序列进行排序
- 使用sorted()排序不会影响原来的对象,而是返回一个新对象
-
-
装饰器
-
希望函数可以在计算前,打印开始计算,计算结束后打印计算完毕
-
可以直接通过修改函数满足需求,但产生如下的问题:
- 如果修改的函数过多,修改过于麻烦
- 不方便维护
- 违反开闭原则(ocp) 程序的设计,要求开发对程序的扩展,要关闭对程序的修改
-
-
类
-
创建类 class 类名:(正常情况下类名需要大写)
-
在类中我们所定义的变量,将会成为所有实例的公共属性,所有实例都可以访问这些变量
-
在类中也可以定义函数,类中定义的函数,我们称为方法.这些方法可以通过该类的所有实例来访问
-
init()函数 在创建一个对象完成时,会自动被调用一般用来初始化对象,self,不需要开发者传递,python解释器会自动把当前对象的引用传递进去.
# 创建一个persion类,类可以有属性,有函数 class Person(): name="吴鹏" age=18 #创建实例对象所传入的参数会跟init有关 # 在使用init的时候,每次创建一个实例对象就会调用一次 def __init__(self,name,age): print("我的姓名是:{},我的年龄是:{}".format(name,age)) def info(self,name,age): print("我的姓名是:{},我的年龄是:{}".format(name,age)) # 创建对象,wp是Person的实例 wp=Person("吴娟",18) # 调用的时类中的属性 print(wp.name) # 调用类中的函数,函数后传入了形参,与之对应会有实参 wp.info("吴磊",18) # 检查一个对象是否是一个类的实例,如果是就是true,如果不是则是false result=isinstance(wp,Person); print(result)
-
在类中创建的方法中会默认添加一个参数,使用pychar系统会给一个self作为参数传递进去
-
-
属性和方法
-
当我们调用一个对象的属性时,解析器会现在当前对象中寻找是否含有该属性,如果有则直接返回当前对象的属性值,如果没有,则去当前对象的类对象中去寻找,如果有则返回类对象的属性值,如果没有则报错
-
类对象和实例对象中都可以保存属性和方法
- 如果这个属性(方法)是所有的实例共享的,则应该将其保存到类对象中
- 如果这个属性(方法)是某个实例独有,则应该保存到实例对象中.
- 一般情况下,属性保存到实例对象中,而方法保存到类对象中
- 在方法中不能直接使用类中的属性,需要使用self.属性名
-
类属性,直接在类中定义的属性是雷属性,类属性可以通过类或类的实例访问到,但是类属性只能通过类对象来修改,无法通过实例对象修改.
-
实例属性,通过实例对象添加的属性属于实例属性,实例属性只能通过实例对象来访问和修改,类对象无法访问修改
-
实例方法可以通过实例和类去调用,当通过实例调用时,会自动将当前调用对象作为self传入,当通过类调用时,不会自动传递self,此时需要手动传递self
-
在类内部使用@classmethod来修饰的方法属于类方法,类方法的第一个参数是cls,也会被自动传递,cls就是当前的类对象,类方法可以通过类去调用,也可以通过实例调用,没有区别
-
在类中使用@staticmethod来修饰的方法属于静态方法,静态方法不需要指定任何的默认参数,静态方法可以通过类和实例去调用,静态方法基本上是一个和当前类无关的方法.它只是一个保存到当前类中的函数,静态方法一般存放的都是一些工具方法
-
-
类的特殊方法
-
在类中可以定义一些特殊方法(魔术方法)
-
特殊方法都是以__ 开头,__ 结尾的方法
-
特殊方法不需要我们自己调用,不要去尝试调用特殊方法.特殊方法会在特殊的时刻自动调用
-
当我们打印一个对象时,实际上打印的是对象中的特殊方法__ str__()的返回值,作用就是制定对象转换为字符串的结果.
-
__ repr __() 这个特殊方法会在对当前对象使用repr()函数时调用
-
__ len __ () 获取对象的长度
-
__ bool __() 返回对象的bool类型
-
object.__ lt __ (self,other) 小于
-
object.__ le __ (self,other) 小于等于
-
object.__ eq __ (self,other) 等于
-
object.__ ne __ (self,other) 不等于
-
object.__ gt __ (self,other) 大于
-
object.__ ge __ (self,other) 大于等于
class Person: # 魔术方法比较对象 def __init__(self,name,age): self.name=name self.age=age def __lt__(self, other): return self.age>other.age p1=Person("吴鹏",18) p2=Person("吴磊",20) print(p1.age>p2.age)
-
__ init __可以在新创建的对象中初始化属性
class Person(): name="吴鹏" age=18 def __init__(self,name,age): self.name=name self.age=age def info(self): print("我叫:{},今年:{}" .format(self.name,self.age)) wp=Person("吴鹏",18) wp.info()
-
-
创建对象的流程
- 创建一个变量
- 在内存中创建一个新对象
- 执行类的代码块中的代码
- __ init __(self)方法执行(只在类定义的时候执行一次)
- 将对象的id赋值给变量
-
封装 (确保对象中的数据安全)
-
隐藏对象中一些不希望被外部所访问到的属性或方法
-
如何隐藏一个对象中的属性?
- 将对象的属性名,修改为一个外部不知道的名字
-
如何获取(修改)对象中的属性
- 需要提供一个getter和setter方法使外部可以访问的属性
-
property装饰器
- @property 奖get方法转换为对象的属性
- @属性名.setter 可以像调用属性一样使用get方法
class Person: def __init__(self, name): self.name = name # property装饰器,用来将一个get方法,转换为对象的属性 # 添加为property装饰器后,我们就可以像调用属性一样使用get方法 @property def get_name(self): return self.name # 指定setter方法的装饰器 @属性名.setter @get_name.setter def get_name(self,name): self.name=name p = Person("吴磊") print(isinstance(obj,p)) print(p.get_name)
-
-
继承 (保证了对象的扩展性)
-
通过继承可以使一个类获取到其他类中的属性和方法
-
在定义类的时候,可以在类名后的括号中指定当前类的父类(超类),子类可以直接继承父类中的所有的属性和方法
-
通过继承可以直接让子类获取到父类的方法或属性,避免编写重复性的代码,并且也符合ocp原则,所以我们经常需要通过继承来对一个类进行扩展
-
在创建类时,如果省略了父类,则默认父类为object,object是所有类的父类,所有类都继承自object,所有的对象都是object的实例
-
多重继承
- 在python中是支持多重继承,也就是我们可以为一个类同时指定多个父类
- 在类名的()后面添加多个类,逗号隔开来实现多重继承
- 多重继承,会使子类同时拥有多个父类,并且会获取到所有父类中的方法
- 在开发中没有特殊的情况,尽量避免使用多重继承,因为多重继承会让我们的代码过于复杂
- 如果多个父类中有同名的方法,则会在第一个父类中寻找,然后找第二个,然后找第三个,第一个直接就将其他几个类的方法直接覆盖掉
- 出现多重继承,如果子类继承了父类,还继承了父类的父类,那么首先先去自身类中寻找,其次在到上一级父类寻找,最终在到父类的父类中寻找,一直到object
-
重写
- 如果在子类中有和父类同名的方法,则通过子类实例去调用方法时,会调用子类的方法而不是父类的方法
- 当我们调用一个对象的方法时,会优先去当前对象中寻找是否具有该方法,如果有则直接调用,如果没有则去当前对象的父类中寻找,如果父类中有则直接调用父类中的方法,如果依然没有则去父类的父类中寻找,一直找到object,如果依然没有找到,则报错.
- 父类中的所有方法都会被子类继承,包括魔术方法,如果希望子类中方法中参数多于父类,可以重写特殊方法包括其他方法
- 如果想要在子类中直接去使用父类的方法,可以使用父类名.方法名(self,参数),不过这种提高了耦合性,所以一般将父类名改成super()这样,父类进行修改的时候,子类动态修改了父类,并且通过super返回对象调用父类方法时,不需要传递self
-
多态 (保证了程序的灵活性)
- 定义一个不在类中的函数,只要对象中有属性,就可以作为参数传递到该函数,这个函数不会考虑对象的类型,只要该对象中有属性即可
- 一般在开发过程中像isinstance()这种函数,在开发中一般是不会使用的
-
-
模块化
-
采用模块化,统一将所有的代码编写到一个文件中
-
优点:方便开发,方便维护,模块可以复用.
-
import语句一般引用在程序的开头位置
-
在一个模块中引入外部模块
- import 模块名
- import 模块名 as 模块别名
- import 目录名.模块名
-
在每一个模块内部都有一个__ name __属性,通过这个属性可以获取到模块的名字
-
访问模块中的变量:模块名.变量名
-
也可以引入模块中的部分内容
- 语法:from 模块名 import 变量1,变量2,...
- 引入所有的变量,类也属于一种特殊的变量 语法:from 模块名 import *,这种情况一般不会使用
- 也可以为引入的变量使用别名 语法:from 模块名 import 变量 as 别名
- 添加了带_的变量,只能在模块内部访问,只针对于访问模块中部分内容带*号的情况
-
编写测试代码,有些代码在当前文件作为主模块的时候才需要执行,而当模块被其他模块引入时,不需要执行,此时我们就必须要检查当前模块是否是主模块
if __name__=="__main__": test() # 调用方法
-
包
- 也是一个模块,包中必须要一个一个__ init __.py这个文件,这个文件中可以包含主要内容
- 如果直接引入包的话,只能直接调用包中的__ init __.py文件中的属性,要想调用其他文件中的属性,需要引入包指定的文件名 语法:from 包名 import 指定文件名
-
-
python的标准库
-
标准库会随python的安装一同安装
-
sys模块
- sys.argv 表示获取执行代码时,命令行中所包含的参数,该属性是一个列表,列表中保存了当前命令的所有参数
- sys.modules 表示获取当前程序中引入的所有模块,modules是一个字典,字典的key是模块的名字,字典的value是模块的对象
- sys.path 是一个列表,列表中保存的是模块的搜索路径
- sys.platform 表示获取当前python运行的平台
- sys.exit() 函数用来退出程序
-
os模块
- os.environ 通过这个属性可以获取到系统的环境变量,如果想要获取指定path的环境变量os.environ[‘path‘]
- os.system() 可以用来执行操作系统的名字 比如目录:os.system(‘dir‘)
-
pprint模块
- pprint.pprint() 用来对打印的数据做简单的格式化
-
-
异常
-
程序运行时出现异常,目的并不是让我们的程序直接终止!python是希望在出现异常时,可以编写代码来对异常进行处理.
-
异常的处理语法:
try 语句 try : 代码块(可能出现错误的语句) except: 代码块(出现错误以后的代码) finally: else: 代码块(没出错时要执行的语句)
-
可以将可能出错的代码放到try语句,这样如果代码没有错误,则会正常执行,如果出现错误,则会执行expect子句中的代码,这样我们就可以通过代码来处理异常,避免因为一个异常导致整个程序的终止.
-
异常的传播
-
当在函数中出现异常时,如果在函数中对异常进行了处理,则异常不会再继续传播,.
-
如果函数中没有对异常进行处理,则异常会继续向函数调用处传播
-
如果函数调用处处理了异常,则不再传播,如果没有处理则继续像调用处传播,知道传递到全局作用域(主模块)如果依然没有处理,则程序终止,并且显示异常信息
-
当程序运行过程中出现异常以后,所有的异常信息会被保存到一个专门的异常对象中,而异常传播时,实际上就是异常对象抛给了调用处
-
如果except后不跟任何的内容,那么此时会补货到所有的异常
-
如果except后跟着一个异常的类型,那么此时只会捕获该类型的异常 except NameError:
-
Exception是所有异常类的父类,所以如果except后跟的是Exception他也会捕获到所有的异常
-
可以在异常类后面跟一个as xx此时的xx就是异常对象
-
finally是无论是否出现异常,该子句都会执行.
print(‘异常出现前‘) l=[] try: print(c) l[10] print(10/0) except NameError: print(‘出现NameError异常‘) except ZeroDivisionError as zde: print(‘出现ZeroDivisionError异常‘,zde) except: print(‘未知异常‘) print(‘异常出现后‘)
-
-
抛出异常
-
可以使用raise语句来抛出异常,raise语句后需要跟一个异常类或异常的实例
def add(a,b): if a<0 or b<0: raise Exception("a跟b不能为负值") return a+b add(-1,20)
-
抛出异常的目的就是,告诉调用者这里调用时出现问题,希望你自己处理一下.
-
自定义异常 class MyError(Exception): 然后调用的时候直接调用MyError就可
-
-
以上是关于python语法的主要内容,如果未能解决你的问题,请参考以下文章