from typing import Iterable, Iterator, final

#=======================================================================================================
# Python 条件控制

# if 语句
# Python中if语句的一般形式如下所示：

# if condition_1:
#     statement_block_1
# elif condition_2:
#     statement_block_2
# else:
#     statement_block_3

if True:
    print("True")
else:
    print("False")

if not True:
    print("True")
else:
    print("False")

if 1 & 0 :
    print("1 & 0 is True")
else:
    print("1 & 0 is False")

x = 10 
if x < 0:
    print("x < 0")
elif x < 1:
    print("x < 1")
elif x < 2:
    print("x < 2")
elif x < 5:
    print("x < 5")
else:
    print("x > 5")


# if 嵌套
# 在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

# if 表达式1:
#     语句
#     if 表达式2:
#         语句
#     elif 表达式3:
#         语句
#     else:
#         语句
# elif 表达式4:
#     语句
# else:
#     语句


if 1 > x:
    if x > 1:
        print("x > 1")
    elif x > 2:
        print("x > 2")
    else:
        print("x < 1")
elif 2 > x:
    print(" 21111")
else:
    print(" 1222")


#=======================================================================================================
# Python 循环语句

# while 循环
# Python 中 while 语句的一般形式：

# while 判断条件(condition)：
#     执行语句(statements)……

while x >= 0:
    print("while x:", x)
    x -= 1

# while 循环使用 else 语句
# 在 while … else 在条件语句为 false 时执行 else 的语句块。
# 语法格式如下：
# while <expr>:
#     <statement(s)>
# else:
#     <additional_statement(s)>

x = 0
while x <= 10:
    print("while else x:", x)
    x += 1
else:
    print("x >= 10")


# for 语句
# Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
# for循环的一般格式如下：
# for <variable> in <sequence>:
#     <statements>
# else:
#     <statements>

for i in range(0, 10):
    print("for i:", i)
else:
    print("over range.")


for i in range(1, 100):
    if (i > 100):
        break
else:
    print("over range i:", i)


for i in range(1, 110):
    if (i < 100):
        continue
    else:
        print("i = ", i)
else:
    print(" for end i:", i)

# pass 语句
# Python pass是空语句，是为了保持程序结构的完整性。
# pass 不做任何事情，一般用做占位语句，如下实例

# 实例
# >>>while True:
# ...     pass  # 等待键盘中断 (Ctrl+C)

for i in 'abcdefgd':
    if i == 'd':
        pass
        print("pass here")
    print("i = ", i)
print("end")



#=======================================================================================================
# 迭代器
# from typing import Iterable, Iterator
# 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
# 迭代器是一个可以记住遍历的位置的对象。
# 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
# 迭代器有两个基本的方法：iter() 和 next()。
# 字符串，列表或元组对象都可用于创建迭代器：
list = [0,1,2,3,4,5,6,7,8,9]
it = iter(list) #创建迭代器对象
print(next(it)) #输出迭代器的下一个元素
print(next(it))

# 注意：for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法。
for i in it:
    print(i, end=" ")
print("\n")


# 创建迭代器:
# 要把对象/类创建为迭代器，必须为对象实现 __iter__() 和 __next__() 方法。
# 正如在Python 类/对象 一章中学到的，所有类都有名为 __init__() 的函数，它允许您在创建对象时进行一些初始化。
# __iter__() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。
# __next__() 方法也允许您执行操作，并且必须返回序列中的下一个项目。

# 创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）：
class Xnumbers:
    def __iter__(self):
        self.a = 1
        return self
    def __next__(self):
        x = self.a
        self.a += 1
        return x

xnum = Xnumbers()
mIter = iter(xnum)

print(xnum.a) # 输出类的a的值
print(next(mIter))
print(next(mIter))
print(next(mIter))
print(next(mIter))
print(next(mIter))


#=======================================================================================================
# Python 函数
# 创建函数
# 在 Python 中，使用 def 关键字定义函数：
# return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

def getmax(a, b):
    '''
    输入a,b返回最大的一个数
    '''
    if a > b:
        return a
    else:
        return b

print(id(getmax))
print(getmax.__doc__)
print(getmax(10, 33))
print(getmax(23, 20))
# print(getmax()) # 函数无默认参数，这里会报错

# 函数参数带默认参数值
def person(name='jim', age=20):
    print("name:",name)
    print("age:", age)
    return '------'
    pass


print(person())
print(person('Orange'))
print(person(age=11))
print(person('LiLei', 33))


# Python 作用域
# 局部作用域
# 在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。
# 在函数内部创建的变量在该函数内部可用：
def xfunc():
    x = 126
    print(x)

xfunc()


# 全局作用域
# 在 Python 代码主体中创建的变量是全局变量，属于全局作用域。
# 全局变量在任何范围（全局和局部）中可用。
gx = 12200
def gxfunc():
    print(gx)

gxfunc()
print(gx)


# Global 关键字
# 如果需要创建一个全局变量，但被卡在本地作用域内，则可以使用 global 关键字。
# global 关键字使变量成为全局变量。
def globalfunc():
    global gl_x
    gl_x = 3322



# 创建模块
# 如需创建模块，只需将所需代码保存在文件扩展名为 .py 的文件中：    
# 在名为 mymodule.py 的文件中保存代码：
# def greeting(name):
#   print("Hello, " + name)
# import mymodule
# mymodule.greeting("Python")
# 
# 注释：如果使用模块中的函数时，请使用以下语法：
# module_name.function_name
# 重命名模块
# 您可以在导入模块时使用 as 关键字创建别名：
# 为 mymodule 创建别名 md：
# import mymodule as md
#
# 模块中也可以包含python数据类型的属性
#


#=======================================================================================================
# Python 类/对象：
# Python 是一种面向对象的编程语言，拥有属性和方法。
# class 关键字 创建类：类（Class）类似对象构造函数。
class ClassA:
    x = 10

CA = ClassA()
print("class A x:", CA.x)


# __init__() 函数
# 上面的例子是最简单形式的类和对象，在实际应用程序中并不真正有用。
# 要理解类的含义，我们必须先了解内置的 __init__() 函数。
# 所有类都有一个名为 __init__() 的函数，它始终在启动类时执行。
# 使用 __init__() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作：
# 创建名为 Person 的类，使用 __init__() 函数为 name 和 age 赋值:
class Person1:
    def __init__(self, name, age):
        print("Person class init:")
        self.name = name
        self.age = age
    def func(self):
        print("Hello name is " + self.name)
    def set_name(self, name):
        self.name = name

p1 = Person1("GOOD", 83)
print(p1.name)
print(p1.age)
print(p1.func())

p1.set_name("Linux")
p1.func()

# del 删除类对象
del p1


# self 参数
# self 参数是对类的当前实例的引用，用于访问属于该类的变量。
# 它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数：
class Person2:
    def __init__(obj, name, age):
        obj.name = name
        obj.age = age
    def func(abc):
        print("World name is " + abc.name)

p2 = Person2("xiaojun", 22)
p2.func()


# pass 语句,只是占位没有实际功能：
# 类定义不能为空，但是如果处于某种原因写了无内容的类定义语句，可以用 pass 语句来避免错误。
class Person0:
    pass


# Python 继承
# 继承允许我们定义继承另一个类的所有方法和属性的类。
# 父类是继承的类，也称为基类。
# 子类是从另一个类继承的类，也称为派生类。
class Person:
    def __init__(self, name, age):
       self.name = name
       self.age = age
    def func(self):
        print("Person name is " + self.name)


class Student(Person):
    def __init__(self, name, age):
        Person.__init__(self, name, age) # 调用父类__init__方法
    def func(self): #子类重写父类方法
        print("Student name is " + self.name)
        Person.func(self) # 调用父类方法
    pass

s1 = Student("cat", 6)
print(s1.name)
print(s1.age)
s1.func()


# 使用 super() 函数
# Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性：
class Student1(Person):
    def __init__(self, name, age):
        super().__init__(name, age)
    def say(self):
        super(self)


dog =  Student1("dog", 102)
dog.func()
print(dog.name)
print(dog.age)


# python 异常处理
# try 块允许您测试代码块以查找错误。
# except 块允许您处理错误。
# finally 块允许您执行代码，无论 try 和 except 块的结果如何。

# try 块将生成异常，因为 h 未定义：
try:
    print(h)
except:
    print("An exception occurred")

# 多个异常
# 您可以根据需要定义任意数量的 exception 块，例如，假如您要为特殊类型的错误执行特殊代码块：
try:
    print(h)
except NameError:
    print("变量没定义")
except:
    print("其他错误")

# Else
# 如果没有引发错误，那么您可以使用 else 关键字来定义要执行的代码块：    
try:
    print("hello world")
except:
    print("有错误产生")
else:
    print("0 error, 0 warning")

# Finally
# 如果指定了 finally 块，则无论 try 块是否引发错误，都会执行 finally 块。
try:
    print("Hi python.")
except:
    print("有错误产生")
finally:
    print("finally ....")

# 引发异常
# 作为 Python 开发者，您可以选择在条件发生时抛出异常。
# 如需抛出（引发）异常，请使用 raise 关键词。
# raise 关键字用于引发异常。
x = 0 # -1 会Exception异常停止
if x < 0:
    raise Exception("Error x < 0")

s = 1 #"h" 会TypeError异常停止
if not type(s) is int:
    raise TypeError("Error s not int")

# With
# 基本思想是with所求值的对象必须有一个__enter__()方法和一个__exit__()方法。
class withdemo:
    def __enter__(self):
        print("In __enter__()")
        return "Python Withdemo."
    def __exit__(self, type, value, trace):
        print("In __exit__()")
    

def do_withdemo():
        return withdemo()

with do_withdemo() as wdemo:
    print("wdemo:", wdemo)
# 返回结果如下：
# In __enter__()
# wdemo: Python Withdemo.
# In __exit__()

with open("python_note.txt") as file:
    data = file.read()