• 注释

1. 定义：让计算机跳过这个代码执行
2. 用三个单引号/双引号都表示注释信息，在Python中单引号与双引号没有区别，但必须是成对出现

          

• 输出与输入

• 程序是有开始，有结束的，程序运行规则：从上而下，由内到外

1. 输出：程序把结果展示给用户  print
2. 输入：用户给计算机下命令     input

• 格式化输入与输出    Python占位符：用特殊占位符来进行占位，然后具体要显示什么值，后面来确定

1. 方式一：使用%d   %s  %f来占位     %(值1，值2，值3）

      %d:整数     %s:字符串   %f:小数

       

  2.方式二：使用{}来表示占位符，  .format(值1，值2，值3）

       

 3. 方式三：在引号面前加f,只适用于变量

      

• 数据类型 

• 整数 int ：表示数据大小，会自动扩容，所以python里面是没有long 、short、byte这些
• 浮点数 float ：python里面的float是双精度浮点数
• 字符串：使用 ' 或者 '' 都可以

1. 如果字符串里面包含双引号，字符用单引号括起来
2. 如果字符串里面包含单引号，字符用双引号括起来
3. 如果两者都包含，使用第三方引号引起来

• 布尔:非0则为true ，在判断字符串时，里面没有数字才为False

    

• 复数 ：实数+虚数 0.99j
• 意义：

1. 不同类型所占的内存空间不同( int 4, float 8, boolean 1, str 变长）
2. 不同类型对应操作不同

• 类型的相互转换：

   

•  变量

• 定义：为了保存所用的结果，用来存储数据的空间。 “=”表示赋值

• 变量由数字，字母，下划线构成

1. 不能包含特殊符号 （ *a ,**a)

2. 数字不可以开头

3. 变量名不可与python关键字重复

• “=”表示赋值  (a=10,b=10)

• 连续赋值，多个变量赋值同一个值（a=b=10)

• 多个变量给多个值 （name,age,id="111",11,"233")

• *来表示一个变量接受多个值（注意只能有一个*)

• 运算符

• 算数运算符

1. + 

2. * 

3.   -   

4. /    ，0不可以做除数，会报错；整数/整数，如果除不尽会得到小数

5. **（进行乘方运算）

6. % 

7.  //(取整除法，针对结果向下取整））

• 关系运算符（<=   >=  ==  !=)

1. 可以针对数字/字符串进行比较（先看首字母在字母表上的顺序，谁小谁排在前面）

2. 浮点数比较存在误差，所以比较的时候需要作差，看差值是否小于预期误差范围

      

• 逻辑运算符(Not >And >Or) ,结果都为True/False

1. and 一假则假

2. or  一真则真

3. not 

• 赋值运算符(=  +=  -=  /=)    Python没有++/--操作

1. Python中字符串可以相加

2. Python中整数可以和浮点数相加

3. Python中布尔值也可以相加（1---True  0---False)

• 成员运算符

• 运算符优先级

1. 算数优先级大于比较优先级

2. 比较优先级大于逻辑优先级

3. 逻辑优先级内部Not >And >Or

• 基础语法 

• 顺序语句

• 条件语句

1. 单分支语法

    

     2. 多分支语法

    

     3. 多项分支

    

• 循环语句

1.     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; 

1. 获取这个值可以直接打印/通过变量来接收返回值 ； 

2.  return表示函数的结束，return后面的代码归属于这个函数也不会执行

3. return后面可以写返回值，也可以不写

• 函数的参数：

1. 可以不写形式参数是可以打印的

2. 写参数，如调用的时候不给参数，那么会报错

3. 不定长参数  * --表示传入数据为元组    **---表示传入类型为字典

#元组--*
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

• 函数的嵌套

1. 函数打印的结果

1. 两个同级函数是可以相互调用的

def fun1():
    print("今天该我了")
    fun2()
def fun2():
    print("今天该你了")
    fun1()
fun2()

1. 函数内部还可以直接定义函数，但是需要调用函数才可以执行

def fun3():
    print("111")
    def fun4():
        print("222")
    fun4()
fun3()

• 作用域函数

    

1. 局部变量修改成全局变量 (global---关键词修改成全局变量，需要先定义）

x=10
def text():
    global x
    x=20
    print(f"函数内部：",{x}) #20
text()
print(f"函数外部：",{x}) #20

1. 循环内部重新定义全局变量，全局变量会被修改

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信息")

• 装饰器

1. 规则：在需要执行函数的头部，加上@---如果存在@后面的函数名称，就会先去执行这个函数
2. 调用装饰器需要在函数头部加上@后面加上装饰器名称，

•     

   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)

1. 应用

#创建英雄
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.属性名称

1. 私有属性的获取与调用和修改

#设置属性
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())

1. 类的公有和私有方法

       私有方法：双下划线开头的方法

#获取类的私有方法：
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())

• 多继承

1. 定义

class 子类名称（父类1，父类2）：
   属性或者方法
""

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/0

 3. 获取异常处理的信息

try:
    #可能会出现的异常，报错的上一行及以上都会执行
    n = 1/0

except Exception as  e:
    print(e)

• 断言 

• 一旦匹配不成功，返回值为False，这时候会抛出异常，终端程序执行

• assert   预期结果==实际结果

自定义报错信息：

• with 和as 

打开文件方式：
file=open(文件路径，编码格式，读取方式）

with open(文件路径，编码格式，读取方式) as f:
print(f.read())