# 这是一个代码的注释

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

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

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部