money = 10
print ("余额：",money)

money = 1
A = type(money)
print(A)

str(111) #将111转化成字符串
A = 3.14
int(A) #将浮点数转化成整数，会丢失精度
float(A) #将整数转化成浮点数

'111'
"111"
A = """ 111 """

"  '1111'   "     #会输出'1111'
"  \'1111   "     #会输出'1111

print ("sdsa"+"sdada")

print ("名字是：%s先生 ,电话是 %s"%("张三",123456788))
print ("名字是：%s先生 ,电话是 %d"%("张三",123456788))
print ("名字是：%s先生 ,电话是 %3.2f"%("张三",88.1))
#输出  名字是：张三先生 ,电话是123456788
#输出  名字是：张三先生 ,电话是088.10

A=1,B=2
print (f"名字是：{A}先生 ,电话是{12*13}")

A = "123" == "123"

A = 30
if A > 18 :
    print("123")
elif A>10:
    print("1234")
else:
	print("321")
print ("000")

A = "123456"
for x in A:
    print (x)
#结果会循环6次，每次获取A的一位进行处理 输出
1
2
3
....   

for X in range(10):
     print (x)
#循环10次

for a in range(1,10):
    for b in range(1,10):
        if b<=a:
            print (f"{b}*{a}={a*b}\t",end='')
    print()

for i in range(10):
    if i==5:
        continue
    print (i)
    if i==8:
        break
#输出1234678

def AAA (a):
	if a>18:
		return 1
	else:
		return None

if not AAA(13):
	print("未成年")

def AAA ():
    return 1,"SSS"
x,y =AAA()

def AAA (a,b,c=3):#位置，关键字，缺省参数
    return a,b,c,
x,y,z=AAA(1,b=2)
print(x,y,z)

def BBB (*A):#位置不定长参数
    return A
print(BBB(1,2,3,4,5))

def CCC (**A):#关键字不定长参数
    return A
print(CCC(A=1,B=2,C=3))

def A(a,b):
    return a+b
def C(a,b):
    return a*b
def B (X):
    print(X(1,2))
B(A)

def A(a,b):
    return a+b
def C(a,b):
    return a*b
def B (X):
    print(X(1,2))
B(lambda a,b:a*b*b+a*a-b)

A = [23,24,25,26]
B = [28,29]
A.append(27)
A.extend(B)
print (A[0],A[6])
C =range(len(A))
for i in C:
    print(A[i])
i=0
while i<len(A):
    print(A[i])
    i +=1

A =((1,2,3),[4,5,6])
A[1][2]=7
print(A[1][2])

A ="I IS ABC"
B =A.index("IS")
print(B)
C =A.replace("ABC","大帅哥")
print(C)
D =C.split(" ")
print(D)
E=C.strip("I")
print(E)
E =C.count("I")
print(E)
E =len(C)
print(E)

A ="I IS ABC"
B=A[0::3]
print(B)
A =[[1,2],3,4,5,6]
B=A[::3]
print(B)
A =[[1,2],3,4,5,6]
B=A[::-1]
print(B)

A =[1,2,3,4,5,6,1,2,3,4,5,6,7]
B =set()
for i in A:
    B.add(i)
for i in B:
    print(i)

A= {"ab":66,"bc":77,"bc":88}
B=A["bc"]
print(B)

A= {"张三":{"语文":100,"数学":88,"英语":77},"李四":{"语文":75,"数学":75,"英语":75},"王五":{"语文":0,"数学":36,"英语":100}}
print (A["张三"]["语文"])
A["张三"]["语文"]=99
A["张三"].pop("英语")
A["张三"]["日语"]=92
print (A["张三"])
for i in A:
    print(f"{i}:{A[i]}")

f = open("123.txt","r",encoding="UTF-8")
x = open("123备份.txt","a",encoding="UTF-8")
for i in f:
    a = i.strip()
    b =a.count("测试")
    if b==0:
     x.write(i)
    else:
     continue
f.close()
x.close()

try:
    f = open("1234.txt","r",encoding="UTF-8")
except:
    print("没有这个文件，改为写入创造文件")
    f = open("1234.txt", "w", encoding="UTF-8")

try:
    print(a)
except NameError as i:#NameError是变量未定义的异常
    print(i)

try:
    print("11")
except Exception as i:
    print(i)
else:
    print("22")
finally:
    f.close()

def a():
    n=1/0
def b ():
    try:
        a()
    except Exception as i:
        print(i)
b()

__all__ = [ '函数1']

import json

A ={"name":"张三","phone":12345678910}
A = json.dumps(A)

A = json.loads(A)

import json
import pyecharts.options as opts
from pyecharts.charts import Line

YD = open("印度.txt","r",encoding="UTF-8")
US = open("美国.txt","r",encoding="UTF-8")
RB = open("日本.txt","r",encoding="UTF-8")

#读取文件为字符串，删除不规范的内容
YD_SJ = YD.read().strip("jsonp_1629350745930_63180(",)
US_SJ = US.read().strip("jsonp_1629344292311_69436(")
RB_SJ = RB.read().strip("jsonp_1629350871167_29498(")
#从-2开始读取到最前，删除最后的2个不规范分号
YD_SJ =YD_SJ[:-2]
US_SJ =US_SJ[:-2]
RB_SJ =RB_SJ[:-2]

#json转成python
YD_SJ = json.loads(YD_SJ)
US_SJ = json.loads(US_SJ)
RB_SJ = json.loads(RB_SJ)

#获取国家
US_name = US_SJ["data"][0]["name"]
YD_name = YD_SJ["data"][0]["name"]
RB_name = RB_SJ["data"][0]["name"]

#获取时间
US_trend_time = US_SJ["data"][0]["trend"]["updateDate"][:314]
YD_trend_time = YD_SJ["data"][0]["trend"]["updateDate"][:314]
RB_trend_time = RB_SJ["data"][0]["trend"]["updateDate"][:314]
#获取确诊
US_trend_list_qz = US_SJ["data"][0]["trend"]["list"][0]["data"][:314]
YD_trend_list_qz = YD_SJ["data"][0]["trend"]["list"][0]["data"][:314]
RB_trend_list_qz = RB_SJ["data"][0]["trend"]["list"][0]["data"][:314]

#获取治愈
US_trend_list_zy = US_SJ["data"][0]["trend"]["list"][1]["data"][0]
#获取死亡
US_trend_list_sw = US_SJ["data"][0]["trend"]["list"][2]["data"][0]
#获取新增
US_trend_list_xz = US_SJ["data"][0]["trend"]["list"][3]["data"][0]

#制图
x_data = US_trend_time
y_data = US_trend_list_zy
(
    Line()
    .add_xaxis(xaxis_data=x_data)
    .add_yaxis(
        series_name=US_name,
        stack="确诊",
        y_axis=US_trend_list_qz,
        label_opts=opts.LabelOpts(is_show=False),
    )
    .add_yaxis(
        series_name=YD_name,
        stack="确诊",
        y_axis=YD_trend_list_qz,
        label_opts=opts.LabelOpts(is_show=False),
    )
    .add_yaxis(
        series_name=RB_name,
        stack="确诊",
        y_axis=RB_trend_list_qz,
        label_opts=opts.LabelOpts(is_show=False),
    )
    
    .set_global_opts(
        title_opts=opts.TitleOpts(title="疫情确诊数据"),
        tooltip_opts=opts.TooltipOpts(trigger="axis"),
        yaxis_opts=opts.AxisOpts(
            type_="value",
            axistick_opts=opts.AxisTickOpts(is_show=True),
            splitline_opts=opts.SplitLineOpts(is_show=True),
        ),
        xaxis_opts=opts.AxisOpts(type_="category", boundary_gap=False),
    )
    .render("stacked_line_chart.html")
)

import json
from pyecharts.charts import Map
from pyecharts.options import *

f = open("疫情.txt","r",encoding="UTF-8")
A =f.read()
A =json.loads(A)
C =[]
S =A["areaTree"][0]["children"]
for i in S:
    name = i["name"]
    B = i["total"]["confirm"]
    C.append((f"{name}省",B))
print(C)
map =Map()
map.add("中国确诊人数",C,"china")
map.set_global_opts(
    title_opts= TitleOpts(title="全国疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True ,  #是否显示
        is_piecewise=True,   #是否分段
        pieces=[                    #自定义分段
            {"min":1,"max":99,"lable":"1-99人","close":"#FFE7BA" },
            {"min":100,"max":1000,"lable":"100-1000人","close":"#FA8072" },
            {"min":1001,"max":10000,"lable":"1001-10000人","close":"#FF6347" },
            {"min":10001,"max":50000,"lable":"10001-50000人","close":"#FF3030" },
            {"min":50000,"lable":"50000以上","close":"#8B1A1A" }

        ]
    )
)
map.render()

class 类名 :
    变量1
    方法：
    def 方法名 (self ,形参1,....):
        print(self.变量1)

对象名 = 类名()
对象名.方法()

def __init__(self,形参1.....):
    函数体

class student:
    def __init__(self,name,age):
        self.name =name
        self.age =age
student = student("张三",12)  
print(student)
	#<__main__.student object at 0x00000231C7726900>

def __str__(self):
        return f"我是{self.name}，{self.age}岁"
print(student)    
    #我是张三，12岁

student1 = student("张三",12)
student1 = student("李四",16)

def __lt__ (self,other):#只能判断大小
        return self.age <other.age
def __le__ (self,other):#能判断大小等于
        return self.age <=other.age   
def __eq__ (self,other):#能判断等于
        return self.age ==other.age      

print(student1<student2)
print(student1<=student2)
print(student1==student2)

class student :
    name = "asd"
    __id =123
    def A (self):
        print(f"我的名字是{self.name}")
    def __B(self):
        print(f"我的身份证是{self.__id}")
    def C(self):
        self.__B()
A= student()
A.C()

class 类名 父类名1:
    A =1

class 类名(父类名1，父类名2):		#左边优先
    A =2			#复写
    父类名1.A

    

变量：
A : int = 10
B : float =3.14
C : bool =True
D : str = "asdf"

类对象：
class student :
 pass
AA : student = student()

容器:
a : list = [1,2,3]
b : tuple = (1,2,3)
c : set ={1,2,3}
d : dict ={"asd":666}
e : str = "123dsa"

详细：
a : list[int] = [1,2,3]
b : tuple[int,str,bool] = (1,"a",True)
c : set[int] ={1,2,3}
d : dict[str,int] ={"asd":666}

a = [1,2,3]	#type:list
b = (1,2,3)	#type:tuple
c = {1,2,3}	#type:set
d = {"asd":666}#type:dict[...]
e = "123dsa"#type:str
.......

形参：
def aaa(a : int ,b :class, c:list)

返回值类型：-> 类型 :
def aaa(a) -> int :

from typing import Union

a : list[Union[str,int]]= [1,2,"asd",3] #这样表示list里面可以是str，也可以是int ，二选一
d : dict[str,Union[str,int]] ={"asd":666,"阿是":"ASDD"}

def aaa(a : Union[str,int])->Union[str,int]:

class A:
    def speak(self):
        pass			#抽象类，不进行具体行为，只规定行为
class B(A):
    def speak(self):
        print("azxcv")
class S(A):
    def speak(self):
        print("123456")
def C (AAA:A):
    A.speak()
C(B) #azxcv
C(S) #123456

import json
from pyecharts import options as opts
from pyecharts.charts import Bar

class js :
    ma_1 = []
    time_1 = ["01"]
    def hq(self):
        pass

    def hd2(self):
        A = Bar()
        A.add_xaxis(

                self.time_1

        )
        A.add_yaxis("11", self.ma_1)
        A.set_global_opts(
            xaxis_opts=opts.AxisOpts(axislabel_opts=opts.LabelOpts(rotate=-15)),
            title_opts=opts.TitleOpts(title="Bar-旋转X轴标签", subtitle="解决标签名字过长的问题"),
        )
        A.render("ba.html")

class js1(js):
    def hq(self):
        f = open("2011年1月销售数据.txt", "r", encoding="UTF-8")
        m = 0
        q = 0
        for i in f:
            t = i.split(",")[0][8::]  # 获取时间
            if self.time_1[q] == t:
                b = i.split(",")[2]
                b = int(b)
                m = m + b
            else:
                self.time_1.append(t)
                q += 1
                self.ma_1.append(m)
                m = int(i.split(",")[2])
        self.ma_1.append(m)
        print(self.time_1)
        print(self.ma_1)

class js2(js):
    def hq(self):
        f = open("2011年2月销售数据JSON.txt", "r", encoding="UTF-8")
        m = 0
        q = 0
        for i in f:
            t = i.split(",")[0][18:20:]  # 获取时间
            if self.time_1[q] == t:
                b = i.split(",")[2][9::]
                b = int(b)
                m = m + b
            else:
                self.time_1.append(t)
                q += 1
                self.ma_1.append(m)
                m = int(i.split(",")[2][9::])
        self.ma_1.append(m)
        print(self.time_1)
        print(self.ma_1)

def C (A:js):
    A.hq()
    A.hd2()

A =js2()
C(A)

pip install pymysql

from pymysql import Connection
#获取数据库连接的对象
CONN =Connection(
    host= '主机名',
    port=端口,
    user='用户名',
    password='密码'
    autocommit=True#自动确认提交
)
#打印数据库信息
print(CONN.get_server_info())
#关闭数据库
CONN.close()

#修改
#获取游标对象
cursor =CONN.cursor()
#选择数据库
CONN.select_db("数据库名")

#通过游标对象执行SQL语句
cursor.execute("sql语句")

#确认提交修改,如果设置了自动提交则不用
CONN.commit()

#查询
#获取游标对象
cursor =CONN.cursor()
#选择数据库
CONN.select_db("数据库名")

#通过游标对象执行SQL语句
cursor.execute("sql语句")

#获取查询结果(以元组进行保存)
results : tuple = cursor.fetchall()

#遍历查询结果
for i in results:
    print(i)

#导入包
from pyspark import SparkConf,SparkContext

#创建sparkconf类对象，记录spark程序的运行模式和名字
conf = SparkConf().setMaster("local[*]").\		#"local[*]"表示在本机运行
    setAppName("test_spark_app")				#"test_spark_app"表示给pyspark程序起一个名称

#基于sparkconf类对象创建SparkContext类对象
sc = SparkContext(conf=conf)

#打印pyspark运行版本
print(sc.version)

#停止SparkContext对象的运行（停止pyspark程序）
sc.stop()

rdd = sc.parallelize(容器对象)

#输出RDD的内容
print(rdd.collect)

RDD1 = sc.parallelize([1,2,3,4])
RDD2 = sc.parallelize((1,2,3,4))
RDD3 = sc.parallelize("ASDDFF")
RDD4 = sc.parallelize({1,2,3,4})
RDD5 = sc.parallelize({"aa":1,"bb":2})
print(RDD1.collect())
print(RDD2.collect())
print(RDD3.collect())
print(RDD4.collect())
print(RDD5.collect())

[1, 2, 3, 4]
[1, 2, 3, 4]
['A', 'S', 'D', 'D', 'F', 'F']
[1, 2, 3, 4]
['aa', 'bb']

RDD6 =sc.textFile(文件路径)

import os
os.environ["PYSPARK_PYTHON"]="D:\Python/python.exe"

def AAA(A):
    return A*10
RDD1 = sc.parallelize([1,2,3,4])
RDD2=RDD1.map(AAA)
RDD3=RDD2.map(lambda x:x+5)
print(RDD2.collect())#[10, 20, 30, 40]
print(RDD3.collect())#[15, 25, 35, 45]

RDD1 = sc.parallelize(["1,2,3","4,5,6"])
RDD2=RDD1.flatMap(lambda x:x.split(","))
RDD3=RDD1.map(lambda x:x.split(","))

print(RDD2.collect())#['1', '2', '3', '4', '5', '6']
print(RDD3.collect())#[['1', '2', '3'], ['4', '5', '6']]

RDD1 = sc.parallelize([("男",99),("男",88),("女",99),("女",69),("女",100)])
RDD2=RDD1.reduceByKey(lambda a,b:a+b)
print(RDD2.collect())
#[('男', 187), ('女', 268)]

RDD1 = sc.parallelize([1,2,3,4,5,6])
RDD2=RDD1.filter(lambda a:a%2 == 0)
#[2, 4, 6]

RDD1 = sc.parallelize([1,2,2,3,4,5,6,2,3,4,6,5,9])
RDD2=RDD1.distinct()
print(RDD2.collect())
#[1, 2, 3, 4, 5, 6, 9]

RDD1 = sc.parallelize([(3,"a","一号"),(2,"b","二号"),(1,"c","三号")])
RDD2=RDD1.sortBy(lambda a:a[1],ascending=False,numPartitions=1)
print(RDD2.collect())
#[(3, 'a', '一号'), (2, 'b', '二号'), (1, 'c', '三号')]

RDD2.collect()

RDD1 = sc.parallelize([1,2,3,4,5,6])
A=RDD1.take(3)
print(A)
#[1, 2, 3]

RDD1 = sc.parallelize([1,2,3,4,5,6])
A=RDD1.count()
print(A)
#6

os.environ['HADOOP_HOME']="D:/C++笔记/hadoop-3.0.0"

全局设置
conf.set("spark.default.parallelism", "1")
或者传入数据的时候在后面加1
RDD1 = sc.parallelize([1,2,3,4,5,6],1)

RDD1.saveAsTextFile("D:/C++笔记/python/123")

#导入包
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON']="D:/Python/python.exe"
os.environ['HADOOP_HOME']="D:/C++笔记/hadoop-3.0.0"
#创建sparkconf类对象，记录spark程序的运行模式和名字
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
conf.set("spark.default.parallelism", "1")

#基于sparkconf类对象创建SparkContext类对象
sc = SparkContext(conf=conf)


RDD1 = sc.textFile("search_log.txt")
RDD2 =RDD1.map(lambda a:a.split("\t")).\
    map(lambda I:I[0][:2]).\
    map(lambda a:(a,1)).\
    reduceByKey(lambda a,b:a+b).\
    sortBy(lambda a:a[1],ascending=False,numPartitions=1).\
    take(3)
print(RDD2)
#停止SparkContext对象的运行（停止pyspark程序）
sc.stop()

RDD1 = sc.textFile("search_log.txt")
RDD1.map(lambda a:{"时间":a[0],"用户id":a[1]).saveAsTextFile("D:/C++笔记/python/123")

def AAA(name):
    def BBB(age):
        print(f"{name}的年纪：{age}")
    return BBB
f1 =AAA("张三")
f1(13)#张三的年纪：13

def CCC(C):
    def DDD():
        print("欢迎使用ATM")
        C()
        print("拜拜")
    return DDD

def ATM():
    A =100
    print(f"存款为：{A}")

WW =CCC(ATM)
WW()

def CCC(C):
    def DDD():
        print("欢迎使用ATM")
        C()
        print("拜拜")
    return DDD

@CCC
def ATM():
    A =100
    print(f"存款为：{A}")
ATM()

ABC.py
class AAA:
	pass
	
aaa =AAA()

from ABC import aaa
s1 =aaa
s2 =aaa
s2.

class AAA :
    pass

class student (AAA):
    pass

class teachar(AAA):
    pass

class gc ():
    def asc(self,a):
        if a =="s":
            return student()
        elif a =="t":
            return  teachar()

gc =gc()   
s1 = gc.asc("s")
s2 = gc.asc("t")

import threading

import threading
import time
from time import sleep

def sing (a):
    while True :
        print(a)
        sleep(1)
def dance (a):
    while True :
        print(a)
        sleep(1)
aaa =threading.Thread(target=sing,args =("我在唱歌",))
bbb =threading.Thread(target=dance,kwargs ={"a":"我在跳舞"})

aaa.start()
bbb.start()

import socket

socket_server =socket.socket()

socket_server.bind(("localhost"，8888))

socket server.listen(1)
# listen方法内接受一个整数传参数，表示接受的链接数量
# 等待客户端链接

conn,address=socket_server.accept()
# accept方法返回的是二元元组(链接对象，客户端地址信息)
#可以通过变量1，变量2=socket_server.accept()的形式，直接接受二元元组内的两个元素
#result : tuple=socket_server.accept()
#conn=result[0]# 客户端和服务端的链接对象
# address =result[1]# 客户端的地址信息
#accept()方法，是阻塞的方法，等待客户端的链接，如果没有链接，就卡在这一行不向下执行了

print(f"接收到了客户端的链接，客户端的信息是:{address}")

data:str =conn.recv(1024).decode("UTF-8")
#recv接受的参数是缓冲区大小，一般给1024即可
#recy方法的返回值是一个字节数组也就是bytes对象，不是字符串，可以通过decode方法通过UTF-8编码，将字节数组转换为字符串对象
print(f"客户端发来的消息是:{data}")

msg = input("请输入你要和客户端回复的消息:").encode("UTF-8") #encode可以将字符串编码为字节数组对象
conn.send(msg)

conn.close()
socket_server.close()

import socket
socket_client = socket.socket()

socket_client.connect(("localhost"，8888))

socket_client.send("你好呀".encode("UTF-8"))

recv_data =socket client.recv(1024)#1024是缓冲区的大小，一般1024即可。同样recv方法是阻塞的
print(f"服务端回复的消息是:{recv_data.decode('UTF-8')}")

socket_client.close()

import re
s ='python itheima python itheima python itheima'
result =re.match('python',s)
print(result)#<re.Match object;span=(0，6), match='python'>
print(result.span())#(0，6)，匹配的字符串对应的下标
print(result.group())#python，匹配到的内容

s ='1python itheima python itheima python itheima'
result = re.match('python',s)
print(result)#None,如果开头不匹配，则不会继续匹配下去

import re
s ="1python666itheima666python666"
result = re.search("python",s)
print(result)#<re.Match object;span=(1，7)，match='python'>
print(result.span())#(1，7)
print(result.group())# python

#整个字符串都找不到，返回None
s ="itheima666"
result = re.search('python',s)
print(result)#None

import re
s ="1python666itheima666python666"
result = re.findall('python',s)
print(result)#['python'，'python']

s ="1python666itheima666python666"
result =re.findall('itcast',s)
print(result)#[]，如果找不到则返回空列表

s="itheima1 @@python2!!666 ##itcast3"
A =re.findall(r'\d',s)
print(A)#['1', '2', '6', '6', '6', '3']

s="itheima1 @@python2!!666 ##itcast3"
A =re.findall(r'[a-zA-Z]',s)
print(A)#['i', 't', 'h', 'e', 'i', 'm', 'a', 'p', 'y', 't', 'h', 'o', 'n', 'i', 't', 'c', 'a', 's', 't']

import re
s="sdads2a"
A =re.findall(r'[a-zA-Z0-9]{6,10}',s)
print(A)

s="214566"
A =re.findall(r'^[1-9][0-9]{2,11}$',s)
print(A)

s="214566@qq.com"
r =r'(^[\w-]+(\.[\w-]+)*@(qq|163|gamil)(\.[\w-]+)+$)'
A =re.match(r,s)
print(A)

import os

def A (S):
    AAA =[]
    if os.path.exists(S):   #判断路径是否存在
        B =os.listdir(S)    #列出文件夹的内容
        for i in B:
            C =S+ "/" +i
            if os.path.isdir(C): # 判断路径是否是文件夹
                AAA +=A(C)
            else:
                AAA.append((C,i))
    else:
        print("地址错误")
    return AAA

print(A("D:/C++笔记/python/123"))