1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
# 第一个字符必须为字母或者_
# 大小写敏感
_a = 1
a = 2

'''
多行注释
'''
print(_a, a)

# 行与缩进
if a == 2:
    print("a == 2")

'''
Number类型：int 1,bool true,float 1.23,complex 1.1+2j
字符串 变量[头下标:尾下标:步长] 来截取字符串
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
'''
print(type(a))

input("\n\n按下enter键退出")

# Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
# 允许多变量赋值,指定赋值
x = y = z = 1
a, b, c = 1, 2, 3

'''
Number（数字）
String（字符串）
bool（布尔类型）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 
'''

'''
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
'''
a = 111
print(isinstance(a, str))
print(type(a))
# 注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0

# del语句删除一些对象引用。
del a

str = 'Runoob'
# 索引值以 0 为开始值，-1 为从末尾的开始位置。
print(str[0:-1])

# int() 强制转换为整型：
x = int(2.6)
print(x)

# while 循环使用 else 语句
count = 0
while count < 5:
    print(count, " 小于 5")
    count = count + 1
else:
    print(count, " 大于或等于 5")

# Python pass是空语句，是为了保持程序结构的完整性。

'''
列表推导式
[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]
或者 
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
'''
names = ['Bob', 'Tom', 'alice', 'Jerry', 'Wendy', 'Smith']
new_names = [name.upper() for name in names if len(name) > 3]
print(new_names)

# 元组推导式（生成器表达式）
a = (x for x in range(1,10))
# a <generator object <genexpr> at 0x7faf6ee20a50># 返回的是生成器对象

tuple(a) #  使用 tuple() 函数，可以直接将生成器对象转换成元组
# (1, 2, 3, 4, 5, 6, 7, 8, 9)

'''
创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
'''
class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x


myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))

# 生成器
'''
当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

调用一个生成器函数，返回的是一个迭代器对象。
'''


def countdown(n):
    while n > 0:
        yield n
        n -= 1

# 创建生成器对象
generator = countdown(5)

# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3

# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

# lambda arguments: expression
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

'''
__name__属性
一个模块被另一个程序第一次引入时，其主程序将运行。
如果我们想在模块被引入时，模块中的某一程序块不执行，
我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。 
'''
#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

# 内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回: