python 自学总结

# 这是一个代码的注释

注释可以使用# 一般而言#号后面要加空格表示规范，多行注释使用“”“    ”“”符合包裹

# type()这个是判断变量类型

# 变量的形式 meny = 50

# 自己定义叫标识符 不可以使用关键字 不可以用字母开头 规范性 下划线命名法 英文字母全部小写

"""
运算符 + - *乘 / 除 //取整除  % 取余数 ** 幂
字符串的定义: name = "这是一个字符串"
字符串的定义: name2 = """这是一个字符串"""
字符串的定义: name = '这是一个字符串'
"""

# 在字符串内 包含双引号
name3 = "'这是一个字符串'"
# 在字符串内 包含单引号
name4 = '"这是一个字符串"'
# 在字符串内 解除引号效果

# 在字符串内 解除引号效果
name5 = "\"这是一个字符串"

# 字符串的拼接可以在两个字符串的中间用 + 号，但只能用于字符串之间的连接

name6 = "你好"
name7 = "世界"
print(name6 + name7)

# 字符串格式化 %s %表示我要占位了 s 表示将变量变成字符串放入占位的地方
class_num = 57
arr2 = 100000
message = "%s" % arr2
message2 = "%d" % class_num
print("这个一个实验：%s%s" % (class_num, message))

# %d 将内容转换成整形，放入占位位置
# %f 将内容转换成浮点，放入占位位置
# %s 将内容转换字符串，放入占位位置

# 数字精度控制 m.n m是控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效 .n是控制小数点精度，要求是数字，会进行小数的四舍五入
"""
%5d 表示将整数的宽度控制在5位，如数字11被设置为5d，就会变成【空格】【空格】【空格】11，用
三个空格补充宽度，如果是11,253被设置为%5.1f,则输出为【空格】【空格】11.3,四舍五入进一保留一位小数
.4f则是不限制宽度 
"""

# 可以使用f"内容{变量}"这种形式快速来实现格式化(不限数据类型，不做精度度控制)
# 对于上述表达方式可以使用表达式进行使用2
print("%d",{1 + 1})
print(f"{1 + 1}")
print("%d"% (1 + 1))

# input() 数据输入 使用案例 name = input() input 一般值是字符串 有需求可以进行数据转换 比如 int（input（））
# ture 是 真 数字记作1 false 是 假 数字记作0
# 比较运算符  == != < > <= >=
# if 要判断的条件：
#     条件成立时，要做的事情(y有四个空格缩进)
"""
age = int(input("你成年了吗？"))
if age >= 18:
    print("可以进入了！")
print("程序结束")
"""
# if else: 如果···· 否则····
"""
age = int(input("你成年了吗？"))
if age >= 18:
    print("可以进入了！")
else:
    print("程序结束")
"""
# if elif else 多条件判断 （判断是互斥有序的，上一个满足后下一个就不会判断了）
"""
if int(input(print("请输入你猜的数字：1~10"))) == 10:
    print("对了")
elif int(input(print("请输入你猜的数字：1~10"))) == 10:
    print("对了")
else:
    print("游戏结束了")
"""

# if 进行判断嵌套（缩进满足要求即可）
#生成一个随机的数字
""""
import random
num = random.randint(1,10)

# 不换行 end='' 举例 print("  ",end='')
# \t 效果相当于tab建
"""
i = 1

while i <= 9:
    j = 1
    while j <= i:
            print(f"{i} * {j} = {i * j}\t", end='')
            j += 1
    print(" ")
    i += 1
"""

# for 循环 for 临时变量 in 带处理数据集
"""
num = 0
name01 = "这个是一个字符串"
for x in name01:
    if x == 'g':
        num += 1
print(num)
"""

# range 获得一个数字序列 range(5) == [0,1,2,3,4]
# range(num1,num2,step) => 获得一个从怒骂 到num2 的数字序列 step是子长，也就是一次加几，默认是1 ，不包含num2本身
"""
num = 0
for x in range(1,100):
    if x % 2 == 0:
        num += 1
print(num)
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j}*{i}={i*j}\t",end='')
    print(" ")
"""

# continue 中断本次循环，直接进入下一次循环
# break 直接结束所在循环
"""
money1  = 10000
for x in range(1,21):
    import random
    num = random.randint(1, 10)
    if num >= 5:
        money1 -= 1000
        print(f"你是{x}号，你的绩效是{num},达到标准，可以进行领工资，剩余{money1}")
        if money1 <= 0:
            print("公司没有钱了")
            break 
    else:
        print(f"你是{x}号，你的绩效是{num},没有达到标准，不可以进行领工资")
"""

# def my_len(data):(自定义函数)
# 调用 函数名（）
"""
def 函数名(传入参数)：
    函数体
    return 返回值
def add(x,y):
    return x + y
"""

# 函数传参 函数体 遇到return直接判定结束
# 函数返回none 则是说明返回空值 没有实际意义 none 等同于 false
# if not 条件：
# 局部变量 作用在函数体的内部
# global将局部变量修改成全局变量
# 数据容器 列表 元祖 字符串 字典 集合
# 裂变列表 变量名 = 【‘这是一个字符串’,666,true】
# index 方法 用来查看列表的下标值
# insert(下标，元素)，在指定位置插入元素
# 列表【下标】=值 根据下标进行修改值
# 列表.append(元素)，在列表最后追加元素
# 列表.extend(其他数据容器)，在列表后面追加一批
# del 列表【下标】 列表.pop(下标)（相当于取出来，可以用变量接收） 两种删除元素方法
# 列表.remove（元素） 按顺序数，删除对应的第一个元素
# .clear() 列表清空
# 。len()  列表的元素数量
# len(列表名) 计算列表下标长度

"""
ageOfTheStudent = [21,25,21,23,22,20]
ageOfTheStudent.append(31)
ageOfTheStudent.extend([29,33,20])
arr = ageOfTheStudent.remove(21)
arr2 = ageOfTheStudent.pop(30)
arr3 = ageOfTheStudent.index(31)
"""
"""
my_list = [1,2,3,4,5,6,7,8,9,10]
arr3 = []
def my_hans():
    i = 0
    aarr = 0
    while aarr < len(my_list):
        #print(f"{ }")
        if aarr % 2 == 0:
            arr3.insert(i,my_list.pop(aarr))
            i += 1
        aarr += 1
    print(f"{arr3}")

my_hans()
"""

# 元组 不可以修改 元祖名 = （，，，，） 空元祖定义 变量名 = tuple()
# .index 查找摸莫个元素
# .count 统计莫个元素的出现次数
# len() 计算长度
# 字符串的替换 replace(字符串1，字符串2)
# 字符串.split（分隔字符串）按照()中内容进行切分，形成一个新的 列表
# 字符串.strip()不在括号中写值，则是字符串的规整操作（去前后空格）
# 字符串.strip(字符串)则是去除前后指定的字符串，与字符串的顺序没有关系，按照单个字符
# .count 计算字符串中莫个字符出现的个数
"""
s = "itheima itcast boxuegu"
q = s.count("it")
w = s.replace(" ","I")
e = w.split("I")
print(f"{q}")
print(f"{w}")
print(f"{e}")
"""

# 序列是指：内容有序可以使用下标索引的一类数据容器
# 序列切片 从一个序列中，取出一个子序列 序列名 = 序列【开始 : 结束 : 步长（为1可以省略）】
# 步长 取元素的间隔 步长为负，反向取
"""
str1 = "万过薪月，员序程马黑来，nohyp学"
str2 = str1[::-1]
str3 = str2[8:13:]
print(f"{str3}")
"""

# 集合 不支持重复元素 顺序无法保证 不支持下标索引 集合名 = { , , ,}，空集合 变量名 = set()
# 集合.add(元素) 添加元素，集合本身被修改
# 集合.remove(元素)，移除元素
# 变量名 = 集合.pop() 随机取出元素
# 集合.clear 清空集合
# 集合1.difference(集合2) 取出集合1和2的差集，即1有2没有 结果是得到一个新集合
# 集合1.difference_update(集合2) 在集合1内，删除和集合2相同的元素。 集合1被修改
# 集合1.union(集合2) 将集合1和集合2合成新集合 得到一个新的集合
# 集合不能使用while 循环 可以使用for循环
"""
my_lest  = {'黑马程序员','传智教育','黑马程序员','传智教育','it','it','car','car','best'}
my_lest1 = set()
for x in my_lest:
    my_lest1.add(x)
print(f"{my_lest1}")
"""

# 字典的定义 同样使用{} 不过存储的元素是一个个的：键值对 比如： 变量名 = {key: value,key2: calve2....}
# 空字典 变量名 = dict()
# 字典的key 不可以重复 不支持下标索引 但是可以通过key索引 key不能是字典
# 字典【key】 = value 结果：字典被修改，元素被更新 字典key不可以重复，所以对已存在的可以执行上述操作，就是更新value的值
# 字典key不存在即是新增
# 字典.pop(key) 字典中的key被取出
# 字典.clear() 字典内容被清空
# 字典.keys() 取到字典中全部key
"""
myDictionary = {"王力宏":{"部门":"科技部","工资":3000,"级别":1},
                "周杰伦":{"部门":"a部","工资":5000,"级别":2},
                "林俊杰":{"部门":"b部","工资":2000,"级别":1},
                "张学友":{"部门":"a部","工资":7000,"级别":3},
                "刘德华":{"部门":"科技部","工资":6000,"级别":1},}
for x in myDictionary.keys():
    if myDictionary[x]["级别"] == 1:
        myDictionary[x]["级别"] += 1
        myDictionary[x]["工资"] += 1000
print(f"{myDictionary}")
"""

# list(容器) 将容器转化成列表 str(容器) 将容器转化成字符串
# tuple(容器) 将给定容器转换成元组
# set(容器) 将给定的容器转换成集合
# sorted() 内容进行排序，放入列表中 sorted(容器，reverse=True) 反向排序
"""
for 遍历容器
max 容器最大的元素
min() 容器内最小元素
len() 容器元素个数
list()  转换为列表
tuple() 转换为元组
str() 转换为字符串
set() 转换为集合
65 A 97 a 
重头到尾，一位位进行比较，其中一位大，后面无需比较
"""

# return 1,2 return 返回多值 x,y = 函数名 多个变量接收
# 位置传参 传递的参数和定义的参数的顺序及个数必须依照
# 关键字参数 函数调用时通过“键=值”形式传递参数 函数调用时，如果有位置参数时，位置参数必须在关键字参数的面前，但是关键字参数之间不存在先后顺序’
# 缺省传参 缺省传参也叫默认参数，用于定义函数，为函数提供默认值，函数调用时可以不传该默认参数的值 所至位置参数必须出现在默认参数前，包括函数定义和调用
# 作用：当调用函数时没有传递参数，就会使用默认参数是用缺省参数对应的值
# 不定长参数 也叫可变参数，用于不确定调用的时候会传递多少个参数（也可以不传）的场景
# 位置传递 的不定长， def 函数名（*args）:  传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组的类型，这就是位置传递
# 关键字传递 的不定长 def 函数名（**kwargs）： 参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，同样会根据“键=值”组成字典
# 函数作为参数传参 函数的参数可以是一个函数
# lambda 关键字 ，可以定义匿名的函数（无名称） 在程序中一个场景只能临时使用一次 lambda 传入函数： 函数体（只能写一行代码）
# open(name,mode,encoding) name:是要打开的文件目标的字符串（可以包含文件所在的具体路径）
# mode：设计打开文件的模式（访问模式）：只读，写入，追加等
# encoding： 编码格式（推荐使用utf-8）
# f =  open('l路径加文件名'，‘r’,encoding="utf-8) f是函数的文件对象
# r 只读 w 原有内容会删除 文件不存在 创建新文件 a 在原有的内容后写入 文件不存在 则创建新文件
# 文件对象.read(num) num表示从文件中读取的数据的长度
# readLines() 可以按照行的方式把整个文件的内容进行一次性读取，并返回一个列表
# readLine() 一次读取一行
"""
f = open("C:/Users/jojo/Desktop/杂件/oo7.txt",'r',encoding="utf-8")
print(type(f))
"""

# f.close 关闭文件
# with open 可以通过在with open的语句中对文件进行操作 可以在操作完成后自动关闭close文件 避免忘记close的方法
"""
with open ("C:/Users/jojo/Desktop/杂件/oo7.txt","r",encoding="utf-8") as f:
    sum2 = 0
    a = 0
    while a <= 1000:
        a += 1
        if  f.read(1) == "a":
            sum2 += 1
    print(f"{sum2}")
"""

# f.rite("内容") 直接调用它 内容没有真正写入文件，而是进入了缓冲器中
# f.flush() 内容刷新 这个时候才是真正写入文件
# bill.txt.bak
# 移除 bug
"""
bug捕获  tey:
            可能会发生错误的代码
        except:
            如果出现异常执行的代码
"""
"""
捕获指定异常
        tey:
            可能会发生错误的代码
        except NameError as e:
            如果出现异常执行的代码 指定 变量名没定义
"""
"""
捕获多个异常
        tey:
            可能会发生错误的代码
        except (NameError ZeroDivisionError.....) as e:
            如果出现异常执行的代码 多个异常 可以组成一个元组
"""
"""
异常else
        tey:
            可能会发生错误的代码
        except (NameError ZeroDivisionError.....) as e:
            如果出现异常执行的代码 多个异常 可以组成一个元组
        else:
            如果没有异常需要执行的代码
"""
"""
异常的finally 
        tey:
            可能会发生错误的代码
        except (NameError ZeroDivisionError.....) as e:
            如果出现异常执行的代码 多个异常 可以组成一个元组
        else:
            如果没有异常需要执行的代码
        finally：(表示无论是否异常都要执行)
        f.close()
"""

# python模块的调用 .py结尾
# 【from 模块名】 inport【模块 | 类 | 变量 | 函数 | *】【as 别名】
# 【】 可以不选
"""
improt 模块名1，模块名2。。。。
导入模块
"""
"""
# import time 按住Ctrl 然后鼠标左键点击跳转到源文件
time.函数名
"""

# from 模块名 import 功能名
# 导入时间模块中sleep的方法 from time import sleep
# from 模块名 import * 指把模块内的所有方法都导入
# import 模块名 as 别名 指得是将模块名自定义成一个新的名字
# form 模块名 import 功能 as 别名 指的是 将 模块中方法的名称自定义为一个新的名字
# 当导入多个模块的时候，且模块内有同名功能，当调用这个同名的时候，调用到的是后面导入的模块的功能
# if __name__ == '__main__': 这个是只有当程序是直接执行的才会进入if内部 ，如果是被导入的，则if无法进入
# _all_ 如果一个模块中有_all_变量，当使用form xxx import* 导入时，只能导入这个列表中的元素
# Python包
# 必须在_init_.py中添加_all_ = [] ,控制充需导入的模块列表
# _all_ 只针对form xxx import*
# json 中转数据格式 不同语言的中转站
"""
导入json 
import json
通过 json.dumps() 转换成json 包含中文 json.dumps(容器，ensure_ascii=False) 
json.loads() 将json转换为python
"""
"""
from pyecharts.charts import Line
line = Line()
line.add_xaxis(["中国","美国","法国"])
line.add_yaxis("Gtp",[12,3,4])
line.render()
"""

# 全局设置 line.set.global_opts()
# 列表.sort(key=选择排序依据的函数，reverse=True|False)
# 参数key ，是要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的已依据
# 参数reverse ，是负反转排序结果，true表示降序，False是表示升序

# 设计一个类
class Student:
    name = None
    gender = None
    __ago = None # __开头可以定义一个私有的类对象，这个方法也可以定义一个私有的类方法（函数）
    __is_5G_enable = True
    is_5G_enable = None
    def say_hi(self):
        print("nihao")
# 使用__init__方法 构建方法
    def __init__(self,name,gander):
        self.name = name
        self.gender = gander
    def __str__(self):# __str__ 字符串方法 控制类转换为字符串的行为
        return f"{self.name},{self.gender}"
    def __lt__(self, other): # 大于，小于比较方法
        return self.gender < other.gender
    def __eq__(self, other): # 相等比较
        return self.name == other.name
    def __le__(self, other): # 大于等于 小于等于 比较
        return self.name == other.name
    def __check_5g(self):
        if self.__is_5G_enable :
            print("5Gkaiqi")
            #return True
        else:
            print("NO5g")
            #return  False
    def Call_by_5G(self):
        self.__check_5g()
        print("nihao")
# 单继承
class Student2022(Student):# 在Student的基础上加
    gg = None
    def __eq__(self, other):
        print("")
# 多继承 一个类。可以继承多个父类
# class 类名(父类1，父类2。。。。)：
# pass 补全语法 可以用于空内容时不报错
# 如果父类的成员有同名的话，按照继承的先后顺序判定优先级
# 创建一个对象
# super() 子类中调用父类的成员
# 类型注解 ： 变量：类型 列：my_int: int = 10 my_list: list = [1,2,3]
# 对形参进行注解 def add(x:int,y:int)
# 对返回值进行注解  def add(x:int,y:int) -> int:
#                    return X + y
# Union型
"""
from typing import union
my_list : list[union(int,str)] = [2,"hi"]
"""
# 多肽，指的是：多种状态，即完成摸个行为时，使用不同的对象会得到不同的结果
"""
stu_1 = Student()
stu_1.name = "wp"
stu_1.gender = "男"
"""
# 传参创建一个对象
stu_2 = Student("cgl","nv")
stu_2.Call_by_5G()