#!/usr/bin/python3

if 条件:
    语句
elif 条件:
    语句
else:
    语句

while 条件:
    语句

msg="123"+ \ # 多行语句使用 \
    +"45"
for s in msg:
    print(s) # break与continue 控制循环
else:
    # 循环自然结束时执行

for s in range(5):
    print(s,end='')
# 默认从0开始到5但不取5，输出结果：01234

for s in range(2,5):
    print(s,end='')
# 从2到5但不取5，输出结果：234

for s in range(1,5,2):
    print(s,end='')
# 每次步进2位数，输出结果：13

str='hi'
str="hello"
# 多行字符串
str="""
hello
world\n
"""
# 原始字符串：
str=r"hello world\n" #等于"hello world\\n"

str[0] # 获取单个字符
str[5:] # 切片
str[-10:-1] # 负数则从末尾计数
str[::-1] # 反转字符串

len(str) # 返回字符串长度
str.strip() # 删除开头和结尾的空白字符
str.lower() # 返回小写的字符串
str.upper() # 返回大写的字符串
str.swapcase() # 切换大小写
str.replace('hello','hi') # 返回替换后的字符串
str.split('\n',num) # 返回按指定分隔符分隔的列表,num为分隔次数默认-1分隔全部
print("hello" in str) # 查看某字符串是否存在此字符串中
print("hello" not in str) # 与not搭配使用
str.capitalize() # 首字母大写，其他字母变小写

str.count("str") # 某字符串出现的次数
# find与index类似，查找某串在字符串中的位置
print(str.find("w")) # find(value, [[start], end])
print(str.index("w")) # 参数同上
# 未查找到时：find方法返回 -1，index方法将引发异常

"123abc".isalnum() # 字符串中的字符是否都是字母或数字
"abc".isalpha() # 字符串中的字符是否都是字母
"123".isdigit() # 字符串中的字符是否都是数字

# join按指定分隔符将可迭代对象中的元素，连接为一个字符串
lists=("1","2","3")
print("-".join(lists)) # 1-2-3
d={"name":"ruoxi","value":"123"}
print("+".join(d)) # name+value key的组合字符串

# format 方法格式化
print("{}hello{}world".format(1,"ha"))
print("{1}hello{0}world{0}".format(1,"ha"))
print("{a}hello{b}world{a}".format(a=1,b="ha"))

# f-string 格式化字符串,f'{表达式}'
f'Hello {name}'

# 通过字典设置参数
site = {"name": "name", "url": "www"}
print("网站名：{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
lists=['name', 'www']
print("网站名：{0[0]}, 地址 {0[1]}".format(lists))  # "0" 是必须的
# 还可传入一个对象
print('value 为: {0.value}'.format(obj))

# 格式化数字
print("{0:.2f}".format(3.1415926)) # 保留小数点后两位(为0表示不要小数)
print("{0:+.2f}".format(3.1415926)) # 带符号保留小数点后两位
print("{:0>2d}".format(3)) # 数字补零(填充左边,宽度为2)
print("{0:x<4d}".format(3)) # 数字补零(填充左边,宽度为2)

# %操作符格式化：
# 使用格式：%[(key)][+:右对齐,-:左对齐,0:0填充][字符宽度].[小数位]类型
print("%dhello world%s"%(12,1234)) #元组方式
print("%(key1)d hi world %(key2)s" % {'key1':12,'key2':123}) # 字典方式
print("%-4d" % 5) # 单个元素无须括号包裹
print("%+8.3f" % 2.3)
# 常用类型：%s字符串，%b二进制整数，%d十进制整数
# %o八进制整数，%x十六进制整数，%f浮点数，%%字符"%"

lists1=[0,'1',"2",[3,4,5]]
lists2=['str','hi']
print(lists2[1])
print(lists1)
print(lists1+lists2)

lists2.append("world") # 添加
print(len(lists2)) #长度
lists2.extend(['list']) # 将另一列表元素添加到此列表
lists2.insert(1,'hello') # 插入从0开始
lists2.remove('str') # 移除一个指定元素
lists2.pop() # 移除最后一个元素并返回
lists2.pop(1) # 指定位置移除并返回此元素
lists2.sort() # 对列表元素排序(默认升序)
lists2.reverse() # 将现列表反序
lists1.count('2') # 统计某元素出现的次数
lists1.index('2') # 查找元素
lists1.index('2',1,4) # 指定位置开始在某范围内查找
print(lists2)
print('2' in lists1) # 查找元素是否存在某元素中
del lists1[0] # 删除元素

lists1[:] # 复制此列表返回
lists1[:3] # 从头取到3的前一个元素
lists1[1:] # 从1取到最后一个元素
lists1[2:3] # :后的数字在列表长度内不取，大于列表长度将取到最后一位
lists1[::-1] # 反转数据(反转字符串同理)

t1=(0,'1',"2",[3,4,5])
t2=('str','hi')
print(t1+t2)

num=(1) # 普通数字
t3=(1,) # 元组
t4=1,2 # 有多个元素时不用括号也表示元组

(list1,list2)=("1","2") # 将序列元素赋值给指定变量,列表同([])
print(list1,list2) # 输出：1 2

str="hello"
print(list()) # 返回一个空列表，tuple同
print(list(str)) # 将一个序列元素变为列表
print(tuple(str)) # 将一个序列元素变为列表
print(tuple(list(str))) # 因为list和tuple都是序列可以相互转换
len(tuple(str)) # 返回长度

# 序列中数字和字符串同时存在时使用max或min将报错
print(max(list(str))) # 返回序列中的最大值，max(str)同
min(str) # 最小值同理
sum((1,2,3,4)) # 对数字序列求和(参2可选再加上一数)

list(reversed(str)) # 返回一个反转的迭代器，序列对象可接受并转换
# 将序列组合为一个索引序列，同时列出数据和数据下标，返回enumerate(枚举)对象
print(list(enumerate(str))) # 运行结果：((0, 'h'), (1, 'e'), (2, 'l'), (3, 'l'), (4, 'o'))

# 将序列中对应的元素打包成一个个元组，然后返回由这些元组组成的对象
a=(1,2,3,4) # 4在b中没有对应元素，将被舍去
b=("一","二","三")
print(list(zip(a,b))) # 运行结果：[(1, '一'), (2, '二'), (3, '三')]

import random
random.shuffle(lst) # 将序列的所有元素随机排序
random.choice(seq) # 从序列中随机挑选一个元素

# 定义集合
sets={"set1","set2"}
set(sets) # 接受一个可迭代序列转集合，空参为空集合
set() # 空集合必须使用 set()，{} 表示空字典
print(sets)
for item in sets: # 遍历集合
    print("iemt : "+item)
print("set2" in sets) # 查看某元素是否存在

# 集合运算：
a=set('abc') # {'a', 'c', 'b'}
b=set('bcd') # {'d', 'c', 'b'}
print(a - b) # a包含b不包含的元素(a独有或删除a中b存在的元素)
print(a | b) # ab 中所有的元素
print(a & b) # ab 同时包含的元素
print(a ^ b) # ab 中它们独有的元素

sets=set("abcde")
len(sets) # 集合个数
print('a' in sets) # 判断元素是否存在此集合中
sets.copy() # 拷贝此集合
sets.clear() # 清空集合

# 添加元素：
sets.add("a") # 添加一个元素
# 另一种添加元素方式，可传入可迭代元素(包括字典保存它的key)
sets.update({'b':'2','c':'3'},'e',[1,2])

# 移除元素：
sets.remove("a") # 移除元素并返回，元素不存在则报错
sets.discard("f") # 移除指定元素不存在时不会报错
sets.pop() # 随机移除元素并返回

a={1,2,3}
b={1,2}
a.isdisjoint(b) # 集合是否没有相同元素
a.issuperset(b) # 集合是否是某集合的父集
b.issubset(a) # 集合是否是某集合的子集

# 字典创建key唯一，可以是字符串，数字，元组
d={'a':1,2:2,(1,2):3} # 字典值可以是任何对象
print(d[(1,2)]) # 可以通过键访问和修改值
print("a" in d) # 查看某键是否存在此字典中
d["b"]='b' # 当key不存在时会自动创建
del d['a'] # 删除某元素
len(d) # 元素个数

d.get("a",False) # 根据key获取值不存在时，返回参2的值默认为None
d.setdefault('c','c') # 与get一样，不存在时创建并赋参2值
d.update({'b':'c','d':'d'}) # 将传入的字典数据都添加到此字典中
d.pop('b',False) # 删除指定key，不存在时返回参2值或参2不写将报错
d.popitem() # 删除并返回最后一组键值对组成元组
d.copy() # 返回此字典的拷贝

d.keys() # 返回此字典key的迭代器(可用list()转换为列表)
d.values() # 返回values的迭代器(可list())
d.items() # 返回键值对元组，组成的列表:[(键，值)]
d.clear() # 清空字典

t=(1,2,3) # 创建序列作为key
d=d.fromkeys(t,'def') # 创建一个新字典，参2为值(默认None)
print(d) # {1: 'def', 2: 'def', 3: 'def'}
del d # 删除字典

from datetime import datetime

datetime.now() # 获取当前 datetime
# 用指定日期时间创建 datetime(y, m, d)
datetime(2024, 3, 4, 13, 11, 56, 654634)
datetime.now().timestamp() # 时间戳
datetime.fromtimestamp(t) # 时间戳转 datetime
# str 转换为 datetime
datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
# datetime 格式化为 str
datetime.now().strftime('%Y-%m-%d %H:%M:%S')

# datetime 支持直接加减运算
from datetime import datetime, timedelta, timezone
now = datetime.now()
now + timedelta(days=2, hours=12) # 加减指定天或小时
# 当前东八区时间（上海）
datetime.now().astimezone(timezone(timedelta(hours=8))).strftime('%Y-%m-%d %H:%M:%S')

# 当前时间上海时区
import pytz
datetime.now(pytz.timezone('Asia/Shanghai')).strftime("%Y-%m-%d %H:%M:%S")

def fun(name="long",value="yes",*var):
    '函数第一行字符串作为函数的文档，通过help方法可以查看'
    print(name+value)
    for s in var: # '*':任意参数接受到的值将组成一个元组
        print(s)
    return name #返回值

# 只有运行当前模块(当前的 .py 文件) help 才会执行
if __name__ == '__main__':
    help(fun) # 查看函数文档
fun(value="ha",name="zhang") # 关键字传参(不能传入任意参数的值)
fun("1","2",1,2) # 1，2 作为任意参数组成元组传入

# 任意参数后还有参数时必须用关键字传参
def fun2(*var,str="s"):
    for s in var:
        print(s)
    print(str)
fun2(1,str="ha") # 使用关键字传参给任意参数后面的参数传参

# global：修饰全局变量：
def fun():
    # 在函数内改变外部变量需要加 global 关键字
    global count # 去掉此句 count 将是一个局部变量
    count=2
    print("fun() = %d"%count)
count =1
fun() # 输出：fun() = 2
print("main() = %d"%count) # 输出：main() = 2

# nonlocal 修饰外层变量：
def func1():
    x=2
    def func2(): # 函数内部可嵌套函数
        nonlocal x # 修饰为外部变量，去除此句将报错
        x *=x
        print(x)
    return func2() # 返回内部函数
func1() # 输出：4

# lambda 表达式：
def f1(): # lambda 表达式可以简写此方法
    return 1
# 使用方法：'lambda 参数(多个用逗号隔开): 返回值表达式'
f=lambda : 1 # 它返回的只是一个函数对象
print(f())

f = open("E:/test/str.txt","r",encoding='utf-8') # 1文件路径名 2文件打开模式 3编码格式
print(f.closed,f.name,f.mode) # 文件是否关闭，文件名，模式

print(f.read()) # 传入int参数从文件读取指定的字节数，如果未给定或为负则读取所有
print(f.readline()) # 读取整行，包括"\n"字符(也可传入int指定字节数)
print(f.readlines()) # 读取所有行(直到结束符EOF)并返回列表

f.write(str) # 将字符串写入文件，返回的是写入的字符长度
f.writelines(['第一行\n','第二行']) # 写入序列字符串列表，换行需要自己加入每行的换行符

f.tell() # 返回文件当前指针位置
# seek参1：移动的字节数，是负数表示从倒数第几位开始
# seek参2：0(默认) 从文件头，1 从当前位置，2 从文件末尾
f.seek() # 移动指针，成功返回新位置，失败返回-1
# truncate：从文件首字节开始截断，截断文件为参1个字节，无参表示从当前位置截断
# 必须在能写模式下，`r` 下模式建议使用 `r+`
# 读取模式下截断后不能继续读取，否则数据将不会被删除
f.truncate() # 截断数据，其它数据将被删除

f.flush() # 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件
f.close() # 关闭文件

import os # 导入模块

print(os.sep) # 系统路径分隔符
print(os.linesep) # 系统行终止符
print(os.name) # 工作平台:Windows='nt'，Linux/Unix='posix'
print(os.curdir) # 当前目录："."
print(os.getcwd()) # 当前工作目录
os.chdir("e:"+ os.sep) # 改变当前工作目录
os.system('cmd') # 运行shell命令
print(os.stat(r'E:\test\test.txt')) # 获得文件属性

print(os.listdir()) # 返回目录下文件和文件夹名的列表(可传入路径字符串指定目录)
os.mkdir('e:/a') # 创建一个文件夹，路径错误会文件夹已存在将报错
os.makedirs('e:/a/b/c/d') # 创建多级目录，目录所有目录已存在将报错
os.rmdir('e:/a/b/c/d') # 删除一个空文件夹，非空或不存在会报错
os.removedirs('e:/a/b/c') # 删除目录

import os
file = "e:/test/test.txt"

os.path.abspath(".") # 返回指定路径的绝对路径
os.path.basename(".") # 返回文件名
os.path.dirname(file) # 传入路径的路径名(去除文件名)
os.path.split(file) # 分割文件和路径名组成元组
os.path.splitext(file) # 分割路径文件名和文件扩展名
os.path.join("e:\\","test","test.txt") # 组合路径名(cde等主盘路径不会加反斜杠)

os.path.getatime(file) # 最近访问时间
os.path.getctime(file) # 创建时间
os.path.getmtime(file) # 最近修改时间(可time.gmtime(tiem)查看时间)
os.path.getsize(file) # 文件大小(字节)，文件不存在报错
os.path.exists(file) # 查看路径是否损坏

os.path.isabs(file) # 是否为绝对路径
os.path.isdir(file) # 是否为目录
os.path.isfile(file) # 是否为文件
os.path.islink(file) # 是否为连接
os.path.ismount(file) # 是否为挂载点(如'c:')

try:
    # 语句执行区域
    raise Exception # 抛出一个异常
except:
    print("except") # 异常发生语句执行区
    raise # 不想或无法处理的异常继续抛出
else:
    print("else") # 无异常语句执行区
finally:
    print("finally") # 必执行语句区

# with 关键字无论文件是否打开成功，不再使用后都会关闭
with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

class MyError(Exception): # 继承 Exception 异常类
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)

raise MyError("my define error")

class Class(object): # 括号内表示继承类，多继承可逗号隔开
    name='' # 定义类元素
    def __init__(self,name): # 构造函数
        Class.name="hi" # 定义或对类元素赋值
        self.name=name # 对实例元素name赋值
        self.age=10
    def show(self): # self 表示当前实例对象类似(this)
        print('name=',self.name,',age=',self.age)

c=Class('world') # 创建实例对象
c.show() # 调用方法
Class.name="Class" # 创建或改变类属性值
c.name="self" # 创建或改变实例属性值
print(Class.name) # 访问类属性(实例属性同理)

class Class2(Class): # 继承上 Class 类
    def __init__(self,name): # 子类构造方法也会覆盖父类构造方法，需要自行调用父类构造方法
        super().__init__(name) # 调用父类构造方法(调用父类其它方法同理)
    def show(self): # 重写父类方法
        print(self.name)

c2=Class2("Class2")
c2.show()
# c2.show='a' # 定义属性与方法名同时属性将覆盖方法，调用方法将报错

issubclass(Class2,Class) # 参1(类)是否为参2(类)的子类
isinstance(c,Class) # 参1(实例)是否为参2(类)的实例

# 对类或实例的属性操作方法
hasattr(Class,"name") # 参1(类)是否存在参2属性
hasattr(c,"name") # 实例同理
getattr(Class,"name") # 获取某属性
setattr(Class,"name","value") # 添加或设置某属性值
delattr(Class,"name") # 删除某属性(还可使用del关键字)

class Test:
    def __init__(self): # 初始化
        self.num=1
    def __str__(self): # 类似tostring方法
        return str(self.num)
    def __del__(self): # 实例被删除(del)时调用
        print("实例被del")

    def getnum(self):
        return self.num
    def setnum(self,num):
        self.num=num
    def delnum(self):
        del self.num
    x=property(getnum,setnum,delnum) # 对该属性的操作将调用不同的方法

test=Test()
print(test) # 调用tostring方法

print(test.x) # 调用get方法
test.x=30 # 调用set方法
print(test)
del test.x # 调用del方法
del test