-
注释
- 定义：让计算机跳过这个代码执行
- 用三个单引号/双引号都表示注释信息，在Python中单引号与双引号没有区别，但必须是成对出现
-
输出与输入
- 程序是有开始，有结束的，程序运行规则：从上而下，由内到外
- 输出：程序把结果展示给用户 print
- 输入：用户给计算机下命令 input
- 格式化输入与输出 Python占位符：用特殊占位符来进行占位，然后具体要显示什么值，后面来确定
- 方式一：使用%d %s %f来占位 %(值1，值2，值3）
%d:整数 %s:字符串 %f:小数
2.方式二：使用{}来表示占位符， .format(值1，值2，值3）
3. 方式三：在引号面前加f,只适用于变量
-
数据类型
- 整数 int ：表示数据大小，会自动扩容，所以python里面是没有long 、short、byte这些
- 浮点数 float ：python里面的float是双精度浮点数
- 字符串：使用 ' 或者 '' 都可以
- 如果字符串里面包含双引号，字符用单引号括起来
- 如果字符串里面包含单引号，字符用双引号括起来
- 如果两者都包含，使用第三方引号引起来
- 布尔:非0则为true ，在判断字符串时，里面没有数字才为False
- 复数 ：实数+虚数 0.99j
- 意义：
- 不同类型所占的内存空间不同( int 4, float 8, boolean 1, str 变长）
- 不同类型对应操作不同
- 类型的相互转换：
-
变量
定义：为了保存所用的结果，用来存储数据的空间。 “=”表示赋值
变量由数字，字母，下划线构成
不能包含特殊符号 （ *a ,**a)
数字不可以开头
变量名不可与python关键字重复
“=”表示赋值 (a=10,b=10)
连续赋值，多个变量赋值同一个值（a=b=10)
多个变量给多个值 （name,age,id="111",11,"233")
*来表示一个变量接受多个值（注意只能有一个*)
-
运算符
算数运算符
+
*
-
/ ，0不可以做除数，会报错；整数/整数，如果除不尽会得到小数
**（进行乘方运算）
%
//(取整除法，针对结果向下取整））
关系运算符（<= >= == !=)
可以针对数字/字符串进行比较（先看首字母在字母表上的顺序，谁小谁排在前面）
浮点数比较存在误差，所以比较的时候需要作差，看差值是否小于预期误差范围
逻辑运算符(Not >And >Or) ,结果都为True/False
and 一假则假
or 一真则真
not
赋值运算符(= += -= /=) Python没有++/--操作
Python中字符串可以相加
Python中整数可以和浮点数相加
Python中布尔值也可以相加（1---True 0---False)
成员运算符
运算符优先级
算数优先级大于比较优先级
比较优先级大于逻辑优先级
逻辑优先级内部Not >And >Or
-
基础语法
顺序语句
条件语句
单分支语法
2. 多分支语法
3. 多项分支
循环语句
while循环
2. for 循环
comntinue:立即结束当下循环
break:结束本轮循环
遍历数据应用
-
列表
列表的定义：将多个数据组合在一起的容器
标识符：【 】
关键字： list (在定义变量的时候，不要使用关键字去命名
列表创建好以后是可以改变的（散装辣条）
列表的创建
# 定义了空列表 a=[] #直接给数据 a= [1,2,3,4]
列表的操作
""" 列表的切片操作，可以一次取出一组连续数据 """ b=[1,2,3,4] #此时【1：3】 指的是前闭后开区间 print(b[1:3]) #省略后边界 print(b[1:]) #省略前边界 print(b[:3]) #切片操作涉及步长 print(b[::1]) #步长也可以是负数，从后往前去取 print(b[::-1]) #当切片范围超出有效下标后，不会报错 print(b[1:100:2]) """ 列表的增加操作 列表的变量名.对应方法名 """ #列表插入操作 ,使用append来新增元素，使用insert在任意位置新增 list=[1,2,3,4] list.append(99) print(list) list.insert(2,100) print(list) """ 列表的打印下标元素操作 """ list1=[1,"1111","String",9] print(list1[1]) """ 列表的查询操作 in/ not 打印操作都为true、false """ list2=[1,333,555,7] print(1 in list2) print(1 not in list2) """ 列表与列表之间的操作 + 连接,最好不要使用这个， 用extend在企业里面， """ list3=[3,3,4,4] list4=[5,5,5,5] print(list3+list4) list3.append(list4) print(list3) #字符串是可以当作整个列表的，数字是不可以的，boolean不可以 list3.extend("小加") print(list3) """ 列表的删除操作 pop删除是按照下标删除,从后往前删 ， remove是按照值来删除 """ list6=[1,2,3,4,5,5] # 如果有多个重复数据，会删除靠前面的这一个值 list6.remove(5) print(list6) # 根据下标进行删除,不给下标从后往前删 list6.pop() print(list6) # 请删除列表中的第2至第4个元素，并输出删除元素后的列表 li = ["alex", "WuSir", "ritian", "barry", "wenzhou"] del li[1:4] print(li) """ 修改元素,先要找到具体的值，赋新的值会完成修改 """ list8=[1,1,1,1,1] list8[3]=100 print(list8)
列表有关内存的问题
#有关内存问题 list=[1,2,3,4] #list2与list指向同一个，所以给list3增加数据也会让list增加，工作中不要这样做！！！ list2=list list2.append(99) print(list2) print(list) #切片完成，从新生成 list2=list[0:] list2.append(100) print(list) print(list2)
统计元素个数
""" 统计元素个数,一个萝卜一个坑，如果里面的元素包含数组，那么也不会进行 """ list1=[1,2,4,5,[1,2,3,4]] print(list1.count(2)) //打印出1 #得到下标为4里面的列表的元素中是否包含2 print(list1[4].count(2)) //打印出1
-
字典
字典定义：具有键值对映射关系的一组无序数据集合 key: value (key不变，value是可以随便的变 ）
关键字： dict
标识符： { }
字典的创建
字典的应用
""" 字典的新增，对应不存在的key """ a={ "name":11, "id":123 } a['score']=90 print(a) """ 字典的修改,修改存在的数据 """ a={ "name":11, "id":123 } a['id']="xiaohua1" print(a) """ 字典删除，key不为空,这一类、key都会删除，使用pop ,popitem--从后往前删除 """ a.pop('id') print(a) #从后往前删除 a.popitem() print(a) #清空 cler a.clear() print(a) """ #字典的查找 in not in """ a={ "name":11, "id":123, "xiaohua":123 } print('name' in a) print('name' not in a) """ 取出所有key与value的值,获取所有的键值对 """ a={ "name":11, "id":123, "xiaohua":123 } print(a.keys()) print(a.values()) #获取所有的键值对 print(a.items())
-
元组
标识符：（）
关键字：tuple
定义：元组不可变，程序运行的时候无法改变
面试题：
1.列表和元组的区别？ 列表：可以变的 元组：不可变的，程序运行时候无法改变 2.既然元组不可变，那么存在的意义？ 任何变化的数据都有可能造成安全性问题 ； 处于安全考虑
元组的操作
#获取元组的某个元素 tp=(1,2,3,4) print(tp[-1]) #元组可以生成一个新的元组，并不是元组的拼接 tp1=(1,2,3,4) tp2=('a','b') res=tp1+tp2 print(res) #乘法是把元组进行了两遍的打印 ret=tp1*2 print(ret) #给你元组要进行一些修改，可以转化成列表可变的，修改完在转回来,相当于重定义 tp3=(1,2,3,4) list=list(tp3) print(list) list.append(9) tp3=tuple(list) print(tp3) #元组的赋值 num1=(1,) #为元组类型，元组的值一个都得拿逗号隔开 num2=(1) #为整型 print(type(num1)) print(type(num2))
-
集合
集合定义：由不同元素组成的数据结构（无序排列）
标识符：{ }
集合内的元素，不能重复；集合和集合之间可以做运算
关键字：set
集合的应用
#集合定义 # set={1,"aaa",3,4} # print(set) #集合操作 #查询---需要先转换(转换后列表是有序的），在查询（所以查询是有序的） set={"欢迎","来到","笑话"} list=list(set) print(list[0]) #集合的增加值 add(也是无序的） set={"欢迎","来到","笑话"} set.add("!!!") print(set) #集合的删除,无序的删除---pop set={"欢迎","来到","笑话"} set.pop() #指定的删除---remove（value) set={"欢迎","来到","笑话"} set.remove("来到") print(set) #删除多次也不会报错，就算没有这个数据也可以----discard set={"欢迎","来到","笑话"} set.discard("欢迎") set.discard("欢迎") set.discard("欢迎") set.discard("欢迎") print(set)
集合的运算
#交集：两个集合的相同数据 set1={"xiaoxiao","jiajia"} set2={"xiaoxiao","1111"} print("交集：",set1.intersection(set2)) #并集：合并重复去除掉 print("并集：",set1.union(set2)) #差集：把自己有的对方没有的元素获取 set1={"xiaoxiao","jiajia"} set2={"xiaoxiao","1111"} print("差集：",set1.difference(set2)) #交叉补集：共有部分全部移除掉，只留下独有的部分 set1={"xiaoxiao","jiajia"} set2={"xiaoxiao","1111"} print("差集：",set1.symmetric_difference(set2))
-
函数
定义：将一段代码封装在一个自定义函数名里，这些封装的代码只有调用的时候才执行
在Python中只要求个数，对类型无要求。Python中一个函数可以返回多个值
函数的返回值：函数在执行时需要将执行结果传递给调用函数的位置，所以使用return来进行，如果不写return，直接返回none;
获取这个值可以直接打印/通过变量来接收返回值 ；
return表示函数的结束，return后面的代码归属于这个函数也不会执行
return后面可以写返回值，也可以不写
函数的参数：
可以不写形式参数是可以打印的
写参数，如调用的时候不给参数，那么会报错
不定长参数 * --表示传入数据为元组 **---表示传入类型为字典
#元组--* def print_1(*args): print(args) print_1(1,2,3,4,5) #字典--** def print_1(**kwargs): print(kwargs) print_1(name="xiaojia",id="1",age=10)
函数注释（注释可以写，也可以不写）
#函数的注释与嵌套，函数的注释用来说明当前函数的含义 def fun1(name): """ :param name: //函数的说明 :return: //输入这个还能输之后的结果 """ bool =False if name=="xiaojai": bool=True return bool
函数的嵌套
函数打印的结果
两个同级函数是可以相互调用的
def fun1(): print("今天该我了") fun2() def fun2(): print("今天该你了") fun1() fun2()
函数内部还可以直接定义函数，但是需要调用函数才可以执行
def fun3(): print("111") def fun4(): print("222") fun4() fun3()
作用域函数
局部变量修改成全局变量 (global---关键词修改成全局变量，需要先定义）
x=10 def text(): global x x=20 print(f"函数内部：",{x}) #20 text() print(f"函数外部：",{x}) #20
循环内部重新定义全局变量，全局变量会被修改
x=10 while True: x=20 print(x) break
有关函数的应用
# abs() #绝对值 #divmod() #返回商和余数 x=int(input("输入一个数：")) a,b=divmod(x,2) print(a) #2 print(b) #1 # round() #四舍五入 ,奇数做四舍五入操作，偶数不四舍五入------银行家算法 print(round(1.5)) #2 print(round(2.5)) #2 print(round(3.5)) #4 print(round(4.5)) #4 # pow() #次方
匿名函数（没有名字的函数）--通过lambda来实现匿名函数
lambda 自定义参数：逻辑表达式
函数的调用与引用
def fun1(): print('执行11') fun1() #调用函数 print(fun1) #得到的是函数所在的内存地址，函数本体函数引用：只有函数名称，没有小括号，对应的是这个函数的内存地址
引用+小括号----调用 调用-小括号-----引用
-
日志信息
定义：记录程序运行的流程是否正常，可以解决bug发生的问题，实际过程中python是放在服务器上执行的，我们可以自己写去看实际情况
日志级别
""" 日志的级别： debug调试信息--全部都会输出 info正常输出--不会输出debug warning警告提示--不会输出debug,info error报错信息---只输出一个error级别 级别可以自己设定 """ import logging logging.basicConfig(level=logging.INFO) logging.debug("调试信息") logging.info("正常信息") logging.warning("警告信息") logging.error("错wu信息")
装饰器
- 规则：在需要执行函数的头部，加上@---如果存在@后面的函数名称，就会先去执行这个函数
- 调用装饰器需要在函数头部加上@后面加上装饰器名称，
3.应用
#去上海之前跟我吃饭，到上海后跟我唱歌 import logging def log(func): def b(): logging.info("去上海: ") func() return b @log def func1(): print("跟我一起去吃饭") @log def func2(): print("一起去唱歌") func1() func2()
-
模块和包
模块：文件名（不包含.py后缀）
包：就是python中的文件夹（带有--init--py)
#模块 import time print(time.time()) #from 模块名称 import 函数名称 from time import time print(time())
-
文件
文件读取（需要把文件存储到内存空间里面），文件打开后一定要关闭，打开文件是需要申请一定的系统资源，不在使用文件，资源应该被释放
#文件读取 f=open("C:/111/小明.txt",'r',encoding='utf-8') msg=f.read() print(msg) #按行读取 msg=f.readline() print(msg) #读取出来的数据，存储为列表 cont=f.readlines() for i in cont: print(i) #关闭文件之后是不可以在次进行读取，但是可以打印之前保存的数据 f.close() print(msg)
写文件
#写文件 #W----覆盖写入文件 f=open("C:/111/小明.txt",'w') f.write("凄凄切切钱钱钱钱钱") #a----追加写入 n=0 while n<3: if n==0: print("11111") else: print("22222") n+=1 f.close()如果写入数据在文件里面，直接打开文件的时候，是不可以读取的，因为光标在末尾
-
面向对象
类里面，称之为方法叫做开发所编写生成的功能
class 自定义类： 属性 方法---功能 类里面调用方法的时候需要实例化对象 class Student: name='xiaohau1' age=11 id=20 def eat(self): print("吃东西") def drink(self): print("喝水") #实例化一个对象 xiaoxiao=Student() print(xiaoxiao.name) #对象属性进行修改 xiaoxiao.name="1111" print(xiaoxiao.name)
应用
#创建英雄 class Hero(): name="英雄名字" type="英雄类型" des_1="英雄技能1" des_2="英雄技能2" des_3="英雄技能3" #实例化对象的时候，一定要先执行这个构造函数 def init(self,name,type,desc_1,desc_2,desc_3): #当前变量的值接收进来，给到当前对象的属性 self.name=name self.type=type self.des_1=desc_1 self.des_2=desc_2 self.des_3=desc_3 #技能 def skill_1(self): print("f{name}英雄，释放了--{desc_1}技能") def skill_2(self): print("f{name}英雄，释放了--{desc_2}技能") def skill_3(self): print("f{name}英雄，释放了--{desc_3}技能") #实例化对象 liuban=Hero(name='11',type='22',des_1='33',des_2='44',des_3='55')
封装：封装一个get方法去获取私有属性的值
公有属性：常规属性 私有属性：双下划线开头，只能在自己类中进行调用
类外面使用：对象名称.属性名称
类里面使用：self.属性名称
私有属性的获取与调用和修改
#设置属性 class Person(): #构造函数 def __init__(self,name,age,sex): self.name=name self.age=age # 带有__为私有属性 self.__sex=sex def eat(self): print("1111") #修改私有属性的值, def set_sex(self,newsex): self.__sex=newsex #获取私有属性的值 def get_sex(self): return self.__sex jiashuai=Person("xiaoxiao",1,1) #私有属性的调用 print(jiashuai.get_sex()) jiashuai.set_sex(newsex="笑话") print(jiashuai.get_sex())
类的公有和私有方法
私有方法：双下划线开头的方法
#获取类的私有方法： class Person(): #私有方法 def __eat(self): print("1111") #公有方法 def drink(self): print("2222") #写一个run方法 def run(self): self.__eat() jiashuai=Person() #调用公有方法 jiashuai.drink() #调用私有方法,无法直接调用,需要在类里面写一个run方法 jiashuai.run()
-
继承
定义
class 子类名称（父类名称）： 子类独有的方法或者属性
应用
#父类 class Animal(): name="xiaohau" #私有属性 __age="11" def eat(self): print("公有属性方法") def __drink(self): print("私有属性方法") #获取父类私有属性 def get_age(self): return self.__age #run方法去运行 def run(self): self.__drink() #子类继承父类 class cat(Animal): def sleep(self): print("子类公有属性方法") #实例化猫 lili = cat() print(lili.name) #调用类里面父类的私有属性 print(lili.get_age()) #调用父类里面的私有方法 print(lili.run())
多继承
定义
class 子类名称（父类1，父类2）： 属性或者方法 ""
遵循就近选择，当两个类的方法一致，会就近继承打印
如果依次继承方法--（方法重构），方法重名时，只遵循子类方法执行
class Monkey(): def eat(self): print("吃") class God(): def fly(self): print("fei") def eat(self): print("吃先") class sunwukong (Monkey,God): def qujing(self): print("取取经") swk=sunwukong() swk.fly() swk.eat()
-
多态（支付场景）
应用
class paymennt(): def pay(self): print("支付") class weixin(paymennt): def pay(self): print("微信支付") class zhifubao(paymennt): def pay(self): print("支付宝支付") class aaa(): #设置参数来接收对象的值 def pay(self,oij): #调用这个对象的支付方式 oij.pay() #这个地方传值----重点 ooo=aaa() ali=weixin() ooo.pay(ali) #微信支付
-
异常
异常：程序无法执行下去
异常的解决
1.try ......except
try : 逻辑代码 except: 一旦try里面代码报错，会离立即执行except try: n = 1/0 #0不可以做被除数 print(n) except: print("请检查try里面代码") #异常嵌套 try: n = 1/0 print(n) except: print("请检查try里面代码") #play B str=input("输入字符串：") try: print(str[5]) except: print("输入有无")2. try......finallly
try: 逻辑性代码 finally: 逻辑性代码 try: #可能会出现的异常，报错的上一行及以上都会执行 n = 1/0 except: #对try的异常处理信息 print(111) finally: #不管处理不处理，都要执行 n = 1/03. 获取异常处理的信息
try: #可能会出现的异常，报错的上一行及以上都会执行 n = 1/0 except Exception as e: print(e)
-
断言
一旦匹配不成功，返回值为False，这时候会抛出异常，终端程序执行
assert 预期结果==实际结果
自定义报错信息：
-
with 和as
打开文件方式： file=open(文件路径，编码格式，读取方式） with open(文件路径，编码格式，读取方式) as f: print(f.read())
