#a = type(1)
#a = id('a')
a = int('123')
print(a)
#占位符
#a="heill"
#b="fff %s" %a
#c=f"hhh {b}"
#print(c)

#and or not
#三元运算符  语句1 if 判断 else 语句2
a=10;
b=20;
print('a大') if a>b else print('b大')

#代码块
#if 条件：
#    代码块
if(True):
  print(12)
  print(23)


#缩进一般用tab或者空格（4个）

#input()
#ip = input('提示语')

if False:
    print(1)
else:
    print(2)

#if 判断条件:
#    代码块
#elif 判断条件：
#    代码块
#else：
#    代码块

#while循环,else中会最后执行一次
#循环中，break退出所有循环、continue跳出当前一次循环
i=1
while i<10:
    i+=1;
    print(i);
else:
    print('结束')

#引入模块 from time import *

#列表[],列表中可以保存任意类型的数据
#index可以为负数，倒着数元素
#切片 语法 
#列表[i1:i2],包含开头不包含结尾
#列表[起始:结束:步长]  步长不能为零
# max()  min()  in   not in
#s.index(列表 )  s.count()统计某个元素出现的次数;
ml = [1,2,3,4,5];
ml1 = ['a','b'];
print(ml);
print(len(ml))
print(ml[1:3])

print(ml1*2)
print(max(ml1))
print(ml.count(2))

#修改列表
#通过索引修改 可以配合切片一次性替换多个元素
ml[1] = 99;
del ml[2];
print(ml);

#列表的方法
#append(元素) 追加元素
#insert(索引，元素) 插入元素，不会覆盖已有
#extend() 可以一次性追加多个元素
#clear()   清空列表
#pop(索引)     返回并删除
#remove(元素)  删除指定元素，有多个只删第一个
ml1.insert(1,'c')
print(ml1)

#遍历
i=0;
while i < len(ml):
    print(ml[i])
    i+=1;

for s in ml1:
    print(s);

#range(位数) 相当于range(0，位数，1)
r = range(5)
print(r)
print(type(r))
print(list(range(5)))

#元组，不可变序列 tuple，一般当不希望序列变化时用元组
t1=(3,)
t2=(2,3,6)
print(list(t1))
print(type(t1))


a=1
b=2
#可以省略括号
b,a=a,b
#多个时候可以 *a 接收,例：a,*b= d,e,f,g

# ==比较的对象的值，is  is note对比的对象的id

#dict字典  
#d={key:value,key:value} value只能是不可变对象
#d=(key=value,key=value)  这种方式创建的key都是字符串类型
#in 检查是否有此key ,not in
d={"k1":"ss","k2":"bb"}
d2={"k1":"ss","k2":"bb"}
print(d)
print('k2' in d)

if 'k2' in d:
    print(d['k2'])
    print(d.get('k1'))

d['k1']="bb"
#如果不存在就添加
d.setdefault('k2','hh')
#update合并两个字典，如果有重复key按后面的
d.update(d2)
print(d)
del d['k1']
#popitem 删除并返回（元组）删除的元素
#pop(key)  pop(key,默认值)
d.popitem()
#clear() 清空字典
#copy() 浅拷贝
#keys() 返回所有key
print(d2.keys())
#value() 返回所有值
#item() 返回字典中所有项

#集合set() pop() remove() clear()
s=set()
s={2,4,2,1}
s1 = set('fsd')
print(s1)
#集合的运算 &交集 |并集 -差集 ^异或集（不相交的元素） <=是否是一个集合的子集

#函数
#def 函数名([参数，参数。。。。]):
#   代码块
def fn1():
    print("hello")

fn1()

def fn2(a,b):
    print(a)
    print(b)
    
b=10
c=20    
fn2(b=30,a=10)



#不定长参数
def fn3(a,b,*c):
    print(a,b,c)

fn3(1,2,3,4)

#解包 *对元组解包，**对字典解包
def fn4(a,b,c):
    print(a,b,c)

d=[1,2,3]
fn4(*d)

#返回值，return指定返回值

#文档doc，在函数第一行字符串
def fn5():
    '这是一个文档'
    
help(fn5)    

#变量作用域 ，在函数内部想对全局变量修改需要用关键词：global
a=20;
def fn6():
    global a;
    a=30;
fn6();    
print(a);
    
#命名空间 locals()当前命名空间，globals()全局命名空间

#递归
def fn7(a):
    if(a==1):
        return 1;
    b=a-1;
    return fn7(b)*a;
        
print(fn7(10))

def fn8(a,b,c):
    if((b-a)<=a):
        return True;
    elif(c[a]!=c[b-a]):
        return False;

    return fn8(a+1,b,c);

print(fn8(0,5,"abccba"))

#函数式编程
#filter(函数，集合) ，过滤出集合中符合条件的元素
#map（函数，集合），对集合中所有元素做函数的操作，重新返回一个新的集合

a=[1,2,3];
print(len(a));

#排序
#sort() sort一般是以元素大小进行排序，可以传入一个函数坐稳参数，若此则按照函数返回值大小进行排序
#sorted() 和sort基本一致，但是sorted可以对任意序列进行排序，例 [2,'1','3']

#闭包
def fn9():
    def fn10():
        print("闭包")
    return fn10;    
print(fn9);

#装饰器

#类
class Myclass:
    pass
    def fn1(a,b):
        print('hhh');

#isinstance() 判断两个对象是否属于一类
#类中的方法会默认传递一个参数，所以必须在入参处定义

m1 = Myclass();
m1.fn1(1);

#特殊方法 以__开头和结尾的，不需要调用直接执行
class MyInit:
    def __init__(self):
        print("init了");
        
i = MyInit()

class MyInit1:
    def __init__(self,name):
        self.name=name;
        print("init了");
        
i = MyInit1("hkkk")
print(i.name)
#__双下划线为隐藏属性，在外面访问不到
#@property装饰器，将一个get方法和调用属性一样调用方法
#@属性名.setter ，set装饰器

class MyInit2:
    def __init__(self,name):
        self._name=name;
        print("init了");
    
    @property    
    def name(self):
        return self._name
        
    def setName(self,name):
        self._name=name;
k = MyInit1("hhkkk")
print(k.name)

class Sxz():
    k = 4;
    
a = Sxz();
a.k=6
print(a.k)
print(Sxz.k)

#del特殊方法 __del__ 在对象销毁之前会调用此方法
#__str__ 类中定义打印的返回值
#__gt__ 比较对象大于时调用
#__bool__ 指定对象转换规则
 

class MyC1():
#    def __new__(cls):
#        print("new:"+cls)
        
    def __init__(self):
        print("init:")
    
    def __del__(self):
        print("del:")

    def __str__(self):
        print ("str---")

#p1 = MyC1();

#模块 用import引入
#也可以只引入一个模块的部分内容 语法是 from 模块名 import 变量，变量...
#from m import Person
#引入变量可以取别名 语法 from m import 变量 as 别名
#模块内的私有变量 _开头的变量在外部引入时是不可见的


#异常处理
try:
    print(10/1)
except Exception as e:
    print(e)
else:
    pass
finally:
    pass

#raise 手动抛出异常

#文件
#打开文件 open()  read()读取内容 close()关闭文件
file = open(".\\text.txt");
s = file.read();
print(file)
print(s)
#with...as...语句，自动关闭文件
with open(".\\text.txt") as f:
    print(f.read())

#readline() 每次读一行
#readlines() 将结果封装到list中一次返回

#write() 写操作 如果文件不存在就创建，如果存在就删掉之前内容
file1 = open(".\\text.txt" ,"w",encoding='utf-8')
file1.write('ffff');

# w 写模式
# a 追加模式
# r+ 可读可写 不自动创建文件

file2 = open(".\\text.txt" ,"a",encoding='utf-8')
file2.write("vvvv")

# rb 读取二进制文件  wb写入二进制文件

#tell() 当前读取到的位置
#seek() 读取位置设定