python语法基础

python是一种面向对象的解释型高级编程语言

强类型的动态脚本语言

print函数

print("hhhh","hhhhh") 	#输出：hhhh hhhhh
#sep 用来间隔多个值,不写默认是空格
print("hhhh","hhhhh",sep=',')	#输出：hhhh,hhhhh
#end 设置结尾，不写默认是换行\n
print("hello",end=" ")
print("world")

变量，标识符

a=1
b=2
c=a+b

标识符：定义的变量名，不能用关键字（if,else,等）

数值类型

整型：int 1，2，3

浮点数：float 1.1，1.3

布尔型：bool True(1)/False(0)

复数：complex z=a+bj

查看类型：

print(type(...))

字符串

str “”或’‘

st = "qqq"
s = 'www'

name = """hhhhhhh
llllll
jjjjjj
"""
# 多行注释也是引号
print(name)

字符串编码转换：

a="hello"
a1=a.encode("utf-8")
print("编码前a:",a)
print("编码后a1:",a1)
print(type(a1))

a2 = a1.decode()#解码
print("解码后a2:",a2)
print(type(a2))

字符串常见操作

下标/索引

字符串名[下标]

从左往右数：下标从0开始

从右往左数：下标从-1开始

切片

[起始,结束,步长] 步长也要遵循正负号方向

还是包前不包后原则

[x: ] x到结尾

[ :y] 开头到y的前一个

字符串的查找、修改、判断

格式化输出

1.占位符

#占位符
name = ("qmtt")
print("我的名字：%s" % name)
age = 19
print("我的名字:%s,我的年龄：%d" % (name, age))
# 控制长度
print("%4d" % age)
# 控制输出位数前面用0补全
print("%04d" % age)

#浮点数
a = 1.12345691022
print("%f" % a) #默认输出6位小数，多出来了四舍五入
# 设置小数位数,遵循四舍五入
print("%.10f" % a)

# %%输出一个%
print("我是%%的%%" %())

2.f格式化

# 格式：f"{表达式}"
name = "qmtt"
age = 19
print(f"名字：{name},年龄：{age}")

运算符

算术运算符

注意：

使用/商一定是浮点数且除数不能为0

使用算术运算符,若使用浮点数，结果也用浮点数表示

赋值运算符

a=10
#a=a+1
a+=1
a-=1

输入函数input

输入的为字符串类型（str）

#input
name = input("请输入姓名：")
print("Hello, " + name)
print(name)

转义字符

age = input("What is your age?")
age = int(age)
if age >= 18:
    print("成年")

补充：

print(r"as\\\\dfg")##原生字符串，取消转义

if判断

基本判断

age = input("What is your age?")
age = int(age)
if age >= 18:
    print("成年")

其他

循环语句

while循环

for循环

#for 临时变量 in 可迭代对象：
#字符串就是可迭代对象

# 计数：

# range()用于记录循环次数，相当于一个计数器
# range(start,stop,step)   左闭右开[ )
for i in range(1,10):
    print(i)

break：结束循环

continue：跳过当此循环，进如下一次循环

列表

列表操作：增删查改

添加元素

li = [1,2,3,4,'a','d']
print(li,type(li))
print(li[0],type(li[0])) #有序，可以通过下标访问
print(li[0:3]) #切片操作
#列表也是可迭代对象，可以for循环遍历取值
#列表的常见操作：增删查改
#1.添加元素
li1 = ['one','two','three']
li1.append('four')  #append 整体添加
li1.extend('five')  #分散添加，将元素逐个添加，且里面只能填写可迭代对象
li1.insert(1,'six') #指定位置插入元素，有元素就会后移
print(li1)

修改元素

下标修改

查找元素

和字符串一样

name_list = ['zhangsan','lisi','wangwu']
while True:
    name = input('请输入您的名字：')
    if name in name_list:
        print('已存在，请重新输入')
    else:
        name_list.append(name)
        print(f'成功添加{name}')
        print(name_list)
        break

删除元素

li = ['a','b','c','d','e']
#del li   #删除列表
del li[0] #删除元素
a = li.pop()
li.remove(a) #删除指定元素，重复的话删除第一个
print(li)
print(a)

排序

li = [4,1,5,3,7,2]
li.sort()   #从小到大排序
li.sort(reverse=True) #从大到小
li.reverse() #逆置
print(li)

列表推导式

# 列表推导式
# 格式1：[表达式 for 变量 in 列表]
# in后面不仅可以放列表，还可以放range(),可迭代对象
li = [1,2,3,4,5,6,]
[print(i*2) for i in li] #前面的i是表达式

li1=[]
# for i in range(1,6):
#     print(i)
#     li1.append(i)
# print(li1)
# 使用列表推导式更简单的写法
[li1.append(i) for i in range(10)]
print(li1)

#格式2：添加一种条件
# [表达式 for 变量 in 列表 if 条件]
# 把奇数放到列表里面
li2 = []
[li2.append(i) for i in range(10) if i%2 != 0]
print(li2)

列表嵌套

列表里面嵌套列表

li = [1,2,3,[1,2,3]]
print(li[3])
print(li[3][1])

元组

# 元组tuple
# 基本格式：元组名 = （元素1，元素2，元素3...）
# 小括号
tua = (1,2,3,4,5,'a','c',[1,2,3])
tub = (1,) #只有一个元素的时候，末尾一定要加上‘，’，否则会变成这个元素的数据类型
print(type(tua))
print(tua)

# 元组与列表的区别
# 1.元组若只有一个元素，末尾必须加‘,’
# 2.元组只支持查询操作，不支持增删改
tua1 = (1,2,1,3,4,5,'a','c',[1,2,3])
# tua1[0]= 2  # 会报错
print(tua1[0])
# count(),len(),index(),切片用法和列表相同
print(tua1.count(1))
print(len(tua1))

# # 应用场景
# # 格式化输出，后面的（）本质上就是一个元组
# # 数据不能被修改的时候
name = "qmtt"
age = 18
info = (name,age)
print("姓名是%s,年龄是%d" % (name,age))
print("姓名是%s,年龄是%d"% info)

字典

基本格式

# 字典
# 基本格式：字典名 = {键1:值1,键2:值2,...}
dic = {'name':'qmtt','age':19}
print(type(dic))
dic1 = {'name':'qmtt','name':'qwer'}
print(dic1) # 第一个会被第二个覆盖
#字典中的键具有唯一性，但是值可以重复

常见操作

查找元素

# 常见操作
# 1.查看元素
# 变量名[键名]
dic = {'name':'qmtt', 'age':66}
print(dic['name']) #字典中不能根据下标来访问元素，键名不报错会报错
print(dic['age'])
# 变量名.get(键名)
print(dic.get('age')) # 若键名不存在，默认返回None
print(dic.get('hh', '不存在'))# 若不存在，返回自己设置的默认值

修改元素

# 修改元素
# 变量名[键名] = 值
dic = {'name':'qmtt','age':19}
dic['age'] = 99
print(dic)
# 键名存在就会修改，不存在就会新增

删除元素

# 删除元素
#  1.del
# del 字典名 删除整个字典
# del 字典名[键名] 键值对不存在就会报错
dic = {'name': 'qmtt', 'age': 19}
del dic['age']

# 2.clear 清空字典里的东西，但是保留字典
dic.clear()
print(dic)

# 3.pop
dic = {'name': 'qmtt', 'age': 19}
dic.pop('age')
dic.popitem()#可以指定，默认删除最后一个元素
print(dic）

常见操作2

# 字典常见操作2
dic = {'name':'qmtt','age':20}
print(len(dic))  # len求长度
print(dic.keys()) # 取出所有键名
# for循环取出键名
for i in dic.keys():
    print(i)

print(dic.values()) # 返回所有值
print(dic.items()) # 返回所有键值对,以元组的形式
print(dic)
# 字典的应用场景:
# 用键值对,存储描述一个物体的相关信息

集合

# 集合 set
# 基本格式:集合名= {元素1,元素2,元素3}
# 集合具有无序性
s = {} # 定义空字典
s1 = set() # 定义空集合
print(s1,type(s1))

s2 = {'a','b','c','d','a','d'}
print(s2) #每次运行的结果不一样
s3 = {1,2,3,4,5}
print(s3) #每次运行的结果一样
# 原因:
# 集合无序的设计方式涉及哈希表
print(hash('a')) #
print(hash('b'))
print(hash('c'))
# 每一次运行结果都不一样

# 利用无序性,不能修改集合里的值
# 集合具有唯一性,可以自动去重

常见操作

交集:&

并集:|

类型转换

深浅拷贝

浅拷贝

# 深浅拷贝
# # 赋值,两个对象会一起发生变化
# li = [1,2,3,4]
# print(li)
# li2 = li #将li赋值给li2
# print(li2)
# li.append(5)
# print(li)
# print(li2) #会发现这里li和li2都发生了变化

# 浅拷贝(数据半共享)
# 会创建新的对象,拷贝第一层的数据,嵌套层会指向原来的内存地址
import copy # 导入copy模块
li = [1,2,3,[4,5,6]] #定义一个嵌套列表
li2 = copy.copy(li)
print(li)
print(li2)
# 查看内存地址
print(id(li))
print(id(li2))
# 内存地址不一样,说明不是同一个对象
li[3].append(7)
print(li)
print(li2) #会发现还是被修改了
# 外层的地址不同,但是内层的地址相同
# 优点:拷贝速度快,占用空间少,拷贝效率高

# 深拷贝:数据完全不共享
# 外层的对象和内部的元素全部拷贝了一遍

深拷贝

# 深拷贝:数据完全不共享
# 外层的对象和内部的元素全部拷贝了一遍
import copy
li = [1,2,3,[4,5,6]]
li2 = copy.deepcopy(li)

可变对象

存储空间保存的数据允许被修改，这种类型就是可变类型

常见可变类型：

• 列表 list
• 字典 dict
• 集合 set

函数

基础语法

# 函数
# def 函数名()
#     函数体
def login():
    print("这是登录函数")
    return "登录函数",1,2

print(login()) #可以返回多个值，以元组的形式返回
# 没有返回值，返回none
# return 表示函数结束

def add(x,y):
    return x+y
print(add(1,2))

函数参数

# 1、必备参数（位置参数）
# 含义：传递和定义参数的顺序及个数必须一致
# 格式： def func(a,b)

# 默认参数
# 含义：为参数提供默认值，调用函数时可以不传该默认参数的值
# 所有位置参数必须出现在默认参数前，包括函数定义和调用
# 格式：def func(a,b,c=1)

# 可变参数
# 传入的值的数量是可以改变的，可以传入多个，也可以不传
# 格式：def func(*args)
def func(*args):
    print(args)
    print(type(args))
func(1,2,3,4) # 以元组的形式接收

# 关键字参数
# 格式： def func(**kwargs)
def fund(**kwargs):
    print(kwargs)
    print(type(kwargs)) # 以字典的形式传值
fund(name = 'hhhh',age=999)
# 作用：可以拓展函数的功能

作用域

# 作用域：
# 含义：变量生效的范围
# 全局变量：函数外部的变量，在整个文件中都是有效的
# 函数内部使用变量，会先从函数内部找，有的话直接使用，没有的话会到函数外面找
# 局部变量：函数内部定义的变量，从定义位置到函数结束位置有效
# 只能在被定义的函数中使用，外部不能使用
# 在函数内部被定义，函数调用完成后就销毁


# 函数内部无法修改全局变量的值，更改完全局变量的值并不会改变
# 若要在函数内部修改全局变量的值，要用到关键字global

a = 10
b = 20
def func():
    a = 100
    global b
    b = 200

func()
print(a,b)

# nonlocal
# 用来声明外层的局部变量，只能在嵌套函数中使用，
# 在外部函数先进行声明，内部函数进行nonlocal声明

a = 10
def outer():    # 外函数
    a = 5       # 局部变量
    def inner():    #内函数
        nonlocal a
        a = 20 # 同时对上一层进行修改（上上层不会被修改）
        print('内函数中a的值:',a)

    inner()
    print('外函数中a的值:',a)

outer()
print(a)

# 匿名函数(参数的使用和上面一样)
# 语法：
# 函数名 = lambda 形参 : 返回值
# 调用: 结果 = 函数名(实参)
#
# def add(a,b):
#     return a+b

add = lambda a,b: a+b
print(add(1,2))
# 如果有多个返回值,仍是元组的形式

lambdia结合if判断

# lambda结合if判断
# a = 5
# b = 8
# 三目运算符：
# 为真结果 if 条件 else 为假结果
# print("a比b小") if a<b else print("a比b大")
# 将三目运算当成一个返回值
comp = lambda a,b : "a比b小" if a<b else "a比b大"
print(comp(3,2))

内置函数

# 内置函数
import builtins
print(dir(builtins))
# 大写字母开头一般是内置常量名，小写字母开头一般是内置函数名

# 返回绝对值
print(abs(-10))

# 求和
print(sum([1,2,3])) # 必须是可迭代对象
print(sum((3,4,5))) # 字符串也不可以
print(sum({1,2,3,4,5.1})) # 运算时只要有一个浮点数，结果就也是浮点数

# 求最大最小值
print(min(2,4,5,6,7,))
print(max(2,4,5,6,7,))
# 根据绝对值来求最值
print(max(2,4,5,6,-7,key=abs))

# zip():将可迭代对象作为参数，将对象中对应的元素打包成一个个元组
li1 = [1,2,3]
li2 = ['a','b','c','d']
print(zip(li1,li2)) # 元素个数不一致，按长度最短的来返回
for i in zip(li1,li2):
    print(i)
    print(type(i))

print(list(zip(li1,li2))) # 还是两个必须是可迭代对象


# map():可以对可迭代对象中每一个元素进行映射，分别去执行
# map(func,iter1) func:自己定义的函数，iter1:要放进去的可迭代对象
# 即：对象中的每一个函数都会传入函数执行
li = [1,2,3,4]
def funa(x):
    return x*2
mp = map(funa,li) # 只需写函数名，不用写()
print(list(mp)) #取出方法和上面一样

# reduce()
# 先把对象中的两个元素取出，计算出一个值然后保存着，
# 接下来把这个值跟第三个元素进行计算
from functools import reduce
# reduce(function,sequence)
# function:函数且必须能接收两个参数，
# sequence：序列必须是可迭代对象
li3 = [2,3,5,6]
def add(x,y):
    return x+y

print(reduce(add, li3))

拆包

# 拆包：对于函数中的多个返回数据，去掉元组、列表或字典，直接从里面获取数据的过程
tua = (1,3,4,5)
print(tua)
print(tua[0])
# 方法一：要求元组内的个数与接收的变量个数相同，
# 对象内有多少个数据就定义多少个变量接收
a,b,c,d = tua
print(a,b,c,d)

# 方法二：
a,*b = tua
print(a,b)
# 一般在函数调用时使用
def funa(a,b,*args):
    print(a,b)
    print(args,type(args))
funa(1,2,3,4,5,6,7)
arg = (1,2,3,4,5,6,7)
funa(*arg)

异常

常见异常：

#异常
# try:
# finally:
#程序中出现了问题
# 检测到异常后，解释器就无法再执行了
# print(a) NameError: name 'a' is not defined
# print('a')
# a = 10
# print(a) #这样就正常了

# 抛出异常：rise
# 1.创建一个Exception('xxx')对象，xxx异常提示信息
# 2.raise抛出这个对象（异常对象）
# raise Exception("出现了错误")

# 也可以来写成一个函数来执行：
# def funa():
#     print('funa')
#     raise Exception('funa')
#     # 执行完raise后，后面的代码不会继续往后执行
#
# funa()

def login():
    pwd = input("请输入密码:")
    if len(pwd) >= 6:
        return "密码输入成功"
    else:
        a = Exception("长度不足6位")
        raise a
# print(login())
try:
    print(login())
except Exception as e:
    print(e)
# 捕获异常是为了检测到异常时代码还能继续允许，即程序不会终止

模块

一个py文件就是一个模块，即导入一个模块本质就是执行一个py文件

分类：

1.内置模块：random，time，os，login

2.第三方模块（pip）

3.自定义模块：即自己在项目中自定义的模块

命名要注意，防止和内置模块冲突

# 导入模块
# import 模块名
# 调用：
# 模块名.功能名
# 可以一个import导入多个模块，但最好是一个
import mytest
mytest.funa()

# 方式2：
# from 模块名 import ....
# 这时直接就可以使用功能，没有导入的就不能使用
from mytest import funa
funa()
# 方式3
# from ... import *
# 把模块中所有内容全部导入
# 不建议，因为有时候命名冲突会造成错误

起别名

# as起别名
import mytest as mt
mt.funa()

# 给功能起别名
# from 模块名 import 功能 as 别名
# 导入多个功能，用逗号隔开

# 第一个py文件
# 内置全局变量
# __name__
# 语法：
# if __name__ == "__main__":
# 作用：
# 用来控制py文件在不同的应用场景执行不同的逻辑

# __name__
# 1.文件在当前程序执行（即自己执行自己）：__name__=="__main__"
# 被当作模块导入时，下面的代码不会被显示出来

import pytest2
pytest2.test()

# 第二个py文件
print("会显示的内容")
def test():
    print("test")
if __name__ == "__main__":# 被当作模块导入时，下面的代码不会被显示出来
    print("这是pytest2作为模块不会显示的内容")

包

含义：就是项目结构中的文件夹/目录
# 与普通文件夹的区别:包是含有__init__.py的文件夹

# 作用：将有联系的模块放到同一个文件夹下，有效避免模块名称冲突，让结构更清晰
# 新建包：右键项目名->new->Python package
# import 导入包时，首先执行__init__.py文件的代码
# 不建议在__init__文件中写大量代码
# 导包方式1：
# import pack
# 方式2：
# from pacn import .py 文件

# 包
# 含义：就是项目结构中的文件夹/目录
# 与普通文件夹的区别:包是含有__init__.py的文件夹
#
# 作用：将有联系的模块放到同一个文件夹下，有效避免模块名称冲突，让结构更清晰
# 新建包：右键项目名->new->Python package
# import 导入包时，首先执行__init__.py文件的代码
# 不建议在__init__文件中写大量代码
# 导包方式1：
# import pack
# 方式2：
# from pacn import .py 文件

# __all__:本质上是一个列表，列表里面的元素就代表要导入的模块
# 作用：可以控制要引入的东西
# 包的本质是一个模块，包里还可以包含包

递归函数

# 递归函数
# 条件：
# 1.必须有一个明确的结束条件：递归出口
# 2.没进行一次更深一层的递归，问题规模相比上次递归都要有所减少
# 3.相邻两次重复之间有紧密联系
# # 普通函数来写
# def add():
#     s = 0
#     for i in range(1,101):
#         print(i)
#         s+=i
#     print(s)
# add()

# 递归函数
def add2(n):
    if n == 1:
        return 1
    return n+add2(n-1)

print(add2(100))

# 递归实现斐波那契数列
def Fei(n):
    if n <= 2:
        return 1
    return Fei(n-1)+Fei(n-2)
m = int(input())
li = list()
for i in range(1,m+1):
    li.append(Fei(i))
print(li)

递归的缺点：耗内存

闭包

# 闭包
# 条件：
# 1.函数嵌套
# 2.内层函数使用外层函数的局部变量
# 3.外层函数的返回值是内层函数的函数名
def outer():#外层函数
    n =10
    def inner():
        print(n)
    return inner

print(outer()) # 会打印内函数的内存地址
outer()() # 第一种写法
# 第二种写法：
ot = outer() # 调用外函数
ot()

# 函数引用：
def funa():
    print(123) # 函数名里面保存了函数所在位置的引用
print(funa)
# id(): 判断两个变量是否是同一个值的引用
a = 1
print(a)
print(id(a))
a = 2       # 修改a,生成了新的值，重新赋值给变量a
print(id(a)) # 会发现地址不一样了
print(id(2))
print(id(3))
# 内存地址发生了变化，因为值也发生了变化
def test1(): # test1也是一个函数名，里面存了这个函数所在位置的引用
    print("test1函数")
print(test1) # 内存地址(引用)
te = test1
te() # 通过引用调用函数
# 这就是前面ot加小括号的原因

def outer(m): # 外函数，m是形参，也是外函数的局部变量
    n = 10
    def inner(o=0):
        print("计算结果:",m+n+o)
    return inner # 返回函数名，而不是inner()的原因是inner函数里面的参数较多或者说受到限制时，写法不太规范

# outer(10)
# print(outer(10))
outer(20)()
ot = outer(20)
ot()

# 每次开启内函数都在使用同一份闭包函数
def outer(m):
    print("outer()函数中的值:",m)
    def inner(n):
        print("inner()函数中的值:",n)
        return m+n # 在inner函数中返回m+n的值
    return inner
ot = outer(10) # 调用外函数
# ot(20) # 调用内函数
print(ot(20))
print(ot(30))

# 外函数并不会消亡，而是一直在内存中有一个实例，每次调用内函数就可以引用外函数的局部变量

装饰器

# 装饰器
# 在不修改代码的情况下给函数增加新的功能


# def test02():
#     print("学号：")
# def test(fn):
#     print("姓名：")
#     fn() # 调用要传入的函数
# test(test02)

# 使用装饰器
# 条件：
# 1.不修改原程序或函数的代码
# 2.不改变函数或程序的调用方法

# 标准版装饰器

# 被装饰的函数
def test01():
    print("姓名：")
def test02():
    print("性别")

def outer(fn):    # 外层函数，fn是形参，但是往里面传入的是被装饰的函数名：test01
    # 既包含原有功能，又包含新功能
    def inner(): # 内层函数
        # 执行被装饰的函数
        print("学号：")
        fn()
    return inner
# print(outer(test01()))
# outer(test01())
ot = outer(test02)  # 调用外函数
ot()                 # 调用内函数
# 装饰器的原理就是将原有的函数名重新定义为以原函数为参数的闭包

# 语法糖
# 格式：@装饰器名称
def outer(fn):
    def inner():
        print("学号：")
        fn()
    return inner

@outer # 放在被装饰的函数前，顶格写
def test01():
    print("姓名：")

test01()

# 被装饰的函数有参数
def outer(fn):
    def inner(x): # 内函数，name是内函数的参数
        print(f"{x}是inner函数中的参数")
        fn(x)
    return inner

@outer
def func(x):
    print("这是被装饰的函数")

func(2)
# 或者
ot = outer(func)
ot(3)