# 这是一个代码的注释

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

# 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()