import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is'


    
, 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# print("我是注释，不会执行")
print("正常执行代码")

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
'''
print("Hello, World!") 

"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
"""
print("Hello, World!")

sentence1 = "I love " + 
"python"

sentence2 = ["I", "love",
           "python"]

# int(整数)
a = 3
# float(浮点数)
b = 3.5
#bool(布尔)
c = True
#complex(复数)
d = 4+3j
print(a, b, c, d)

#内置的 type() 函数可以用来查询变量所指的对象类型
print(type(a), type(b), type(c), type(d))

#还可以用 isinstance 来判断
#isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型
print(isinstance(a, int))
print(isinstance(a, float))

# 加
print("Add operation: 5 + 4 = ",5 + 4)
# 减
print("Sub operation: 5 - 4 = ",5 - 4)
# 乘
print("Mul operation: 5 * 4 = ",5 * 4)
# 除，得到一个浮点数
print("Div operation: 5 / 4 = ",5 / 4)
# 除，得到一个整数



    
print("Div operation: 5 // 4 = ",5 // 4)
# 取余
print("Mod operation: 5 % 4 = ",5 % 4)
# 乘方
print("Pow operation: 5 ** 4 = ",5 ** 4)

s1 = "I love python"
s2 = 'I love python'
print(s1)
print(s2)

#索引值以 0 为开始值，-1 为从末尾的开始位置
print("s1首字母字符：", s1[0])
print("s1末尾字母字符：",  s1[-1])
print("输出从第三个开始到第五个的字符:", s1[2:5]) 

#加号 + 是字符串的连接符
#星号 * 表示复制当前字符串，紧跟的数字为复制的次数
str = "I love python "
print("连接字符串:", str + "!!!")
print("输出字符串两次:", str * 2)

#反斜杠  转义特殊字符
#若不想让反斜杠发生转义，可以在字符串前面添加一个 r
print('I
love
python')
print("反斜杠转义失效:",r'I
love
python')

list_a = [1, 2, 3, 4, 5, 6]
list_b = [7, 8, 9]
print(list_a)
print(list_b)

#列表可以被索引和截取，列表被截取后返回一个包含所需元素的新列表
print ("输出完整列表: ", list_a)            
print ("输出列表第一个元素:", list_a[0]) 
print ("从第二个开始输出到第三个元素:", list_a[1:3])       
print ("输出从第三个元素开始的所有元素:", list_a[2:])
print ("连接两次列表:", list_a * 2)
print ("连接列表:", list_a + list_b)

#列表中的元素是可以改变的
list_a = [1, 2, 3, 4, 5, 6]
print("变化前：", list_a)
list_a[0


    
] = 0
list_a[2:5] = [7, 8, 9]
print("变化后：", list_a)

#append()方法：在列表末尾添加新的对象
list_a = [1, 2, 3, 4, 5, 6]
print("添加前：", list_a)
list_a.append(7)
list_a.append(8)
print("添加后：", list_a)

#del语句：删除列表元素
list_a = [1, 2, 3, 4, 5, 6]
print("删除前：", list_a)
del list_a[0]
print("删除后：", list_a)

#len()方法：计算列表长度
list_a = [1, 2, 3, 4, 5, 6]
print("列表长度：", len(list_a))

#max()方法：返回列表元素最大值。min()方法：返回列表元素最小值
list_a = [1, 2, 3, 4, 5, 6]



    
print("列表最小值：", min(list_a))
print("列表最大值：", max(list_a))

#list()方法：将字符串转换为列表
str = '123456'
print("转换后：", list(str))

#count()方法：统计某个元素在列表中出现的次数
list_a = [1, 1, 2, 3, 4, 5, 6]
print("1在list_a中出现的次数：", list_a.count(1))

#index()方法：从列表中找出某个值第一次出现的索引位置
list_a = [1, 2, 3, 4, 5, 6]
print("3第一次出现的位置：", list_a.index(3))

#insert()方法：将对象插入列表指定位置
list_a = [1, 2, 3, 4, 5, 6]
print("插入前：", list_a)
list_a.insert(0 ,7)
print("插入后：", list_a)

#pop()方法：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list_a = [1, 2, 3, 4, 5, 6]
print("默认移除最后一个元素：", list_a.pop())
print("指定移除第一个元素："


    
, list_a.pop(0))

#reverse()方法：翻转列表中元素
list_a = [1, 2, 3, 4, 5, 6]
print("翻转前：", list_a)
list_a.reverse()
print("翻转后：", list_a)

#sort()方法：该方法没有返回值，但是对原列表进行排序
list_a = [1, 3, 2, 5, 4, 6]
print("排序前：", list_a)
list_a.sort()
print("升序排序：", list_a)
list_a.sort(reverse = True)
print("降序排序：", list_a)

tup1 = (1, 2, 3, 4, 5 )
# 元组中只包含一个元素时，需要在元素后面添加逗号,否则括号会被当作运算符使用
tup2 = (50,)
tup3 = (50)
print(type(tup2))
print(type(tup3))

#访问元组:使用下标索引来访问元组中的值
tup1 = (1, 2, 3, 4


    
, 5 )
print ("tup1[0]: ", tup1[0])
print ("tup1[1:3]: ", tup1[1:3])

#修改元组:元组中的元素值是不允许修改的，但可以对元组进行连接组合
tup1 = (1, 2)
tup2 = ('a', 'b')
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

#删除元组：元素值是不允许删除，但可以使用del语句来删除整个元组
tup1 = (1, 2, 3, 4, 5 )
print(tup1)
del tup1
print("删除后的元组 tup1: ")
print(tup1)

#元组运算符：如 + 号和 * 号
tup1 = (1, 2)
tup2 = ('a', 'b')
print("连接：", tup1 + tup2)
print("复制3次：", tup1 * 3)

#len()：计算元组元素个数
tup1 = (1, 2)
print("元组长度：", len(tup1))

#max()方法: 返回元组中元素最大值。min()方法: 返回元组中元素最小值
tup1 = (1, 2)
print("元组最大值：", min(tup1))
print("元组最大值：", max(tup1))

#tuple()方法：将列表转换为元组
list1= ['1', '2']
print("转换前：", list1)
tup1 = tuple(list1)



    
print("转换后：", tup1)

a={'a','b','c'}
b=set('abc')
c=set()
d={}
print(a)
print(b)
print(type(a), type(b), type(c), type(d))

#无序性
a = set('python')
print(a)

#互异性
a = set('good')
print(a)

#add()方法：为集合添加元素
a = set('good')
a.add('p')
print(a)

#update()方法：给集合添加元素
a = set('good')
a.update('p')
print("添加一个元素", a)
a.update(['a', 'b', 'c'])
print("添加多个元素", a)
a.update(['H', 'e'], {'l', 'l', 'o'}) 
print('添加列表和集合', a)

#remove()方法：移除指定元素
s = {'P', 'y', 't', 'h', 'o', 'n'}
s.remove('t')  



    
print("去掉t", s)  

#pop()方法：随机移除元素  
s = {'P', 'y', 't', 'h', 'o', 'n'}
print("随机删除元素：", s.pop()) 

#clear()方法：移除集合中的所有元素
s = {'P', 'y', 't', 'h', 'o', 'n'}
s.clear()  
print("清空集合：", s, len(s))

#issubset()方法：判断指定集合是否为该方法参数集合的子集
A = set('abcd')
B = set('cdef')
C = set('ab')
print("C是否A子集：", C.issubset(A))

#union()方法：返回两个集合的并集，也可以用 |
print("A和B并集:", A|B)
print("A和B并集:",A.union(B))

#intersection()方法：返回集合的交集，也可以用&
print("A和B交集:", A&B)
print("A和B交集:",A.intersection(B))

#difference()方法：差集，也可以用-
print("A和B差集:", A-B)
print("A和B差集:",A.difference(B))

# 用{}创建字典



    
dict1 = {"a":"1", "b":"2"}
print(dict1)
# 用内置函数dict()
dict2 = dict(a="1", b="2")
print(dict2)

#访问字典里的值
dict1 = {"a":"1", "b":"2"}
print ("dict1['a']: ", dict1['a']) #如果没有会报错
print ("dict1.get('a'): ", dict1.get('a')) #如果没有返回None
print("获取所有的key值：", dict1.keys())
print("获取所有的value值：", dict1.values())

#增加新的键/值对
dict1 = {"a":"1", "b":"2"}
print ("增加前：", dict1)
dict1['c'] = 3
print ("增加后：", dict1)

#删除字典指定元素
dict1 = {"a":"1", "b":"2"}
print ("删除前：", dict1)
del dict1['a']
print (


    
"删除后：", dict1)

#清空字典
dict1 = {"a":"1", "b":"2"}
print ("清空前：", dict1)
dict1.clear()
print ("清空后：", dict1)

#dir()方法：查看dict所有方法
print(dir(dict))

#if操作
x = 5
if x > 3:
    print("yes")

#if嵌套:if...elif...else
#也可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中
x = 99
if x<60:
    print("不及格")
elif x<80:
    print("良好")
else:
    print("优秀")

#while循环
sum = 0
counter = 1
while counter <= 10:
    sum = sum + counter
    counter += 1
print("1 到 10 之和为: %d" % sum)

#while 循环使用 else 语句
count = 0



    
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

#for 语句：for循环可以遍历任何序列(列表、字符串等)
str = 'python'
list1 = ['I', 'love', 'python']
print("遍历字符串")
for i in str:
    print(i)
print("遍历列表")
for i in list1:
    print(i)

#range()函数：遍历数字序列，可以使用内置range()函数生成数列
for i in range(5):
    print(i)

#也可以使用range指定区间的值
for i in range(2,6):
    print(i)

#也可以使range以指定数字开始并指定不同的增量(步长),可以是负数
for i in range(0, 10, 3):
    print(i)

for i in range(-10, -100, -30):
    print(i)

#可以结合range()和len()函数以遍历一个序列的索引
list1 = ['I', 'love', 'Python']



    
for i in range(len(list1)):
    print(list1[i])

#break语句：跳出 for 和 while 的循环体
list1 = ['I', 'love', 'Python']
for i in list1:
    if i == 'love':
        break
    print('当前为 :', i)

#continue语句:跳过当前循环块中的剩余语句，然后继续进行下一轮循环
var = 10                    
while var > 0:              
   var = var -1
 # 变量为 5 时跳过输出
   if var == 5:            
      continue
   print ('当前值 :', var)
print ("hello world!")

#pass 语句：pass是空语句，是为了保持程序结构的完整性，pass 不做任何事情，一般用做占位语句
while True:
    pass  # 等待键盘中断 (Ctrl+C)

# 1.无参函数
# 用def定义新函数
def my_func():
    print("test...")
    return


    
 1  
# 调用函数
my_func()   


# 2.有参函数
# 关键字参数、默认参数、可变参数。

# 关键字参数: 调用时指定参数的名称，且与函数声明时的参数名称一致。使用关键字参数允许函数调用时参数的顺序与声明时不一致。
def my_func1(x, y):
    print(x)
    print(y)

# 标准调用
my_func1(1, 2)
# 关键字调用
def my_func1(y = 1, x = 2)

# 默认参数：在函数声明时，指定形参的默认值，调用时可不传入参数（使用默认值）。
def my_func2(x, y=1):
    print(x+y)
    
my_func2(2)

#可变参数:变参数就是传入的参数个数是可变的，可以是1个、2个到任意个。
#在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple。

def my_func3(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

# 函数调用
my_func3()     #返回结果0
my_func3(1,2)  #返回结果5

# 关键字参数：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def


    
 my_func4(x, **kw):
    print ('x:', x, 'other:', kw)

#除了必选参数x外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数。
my_func4(8)

#也可以传入任意个数的关键字参数
my_func4(8, z="66")

#创建类Student
class Student(object):
    "学生成绩"
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))
        
#创建Student类的对象bart
jack = Student('Bart Simpson', 59)
#创建Student类的对象lisa
bob = Student('Lisa Simpson', 87)
#访问类的属性
jack.print_score()
bob.print_score()
# 添加一个 'age' 属性



    
jack.age = 7  
print("添加一个 'age' 属性：",hasattr(jack, 'age'))
# 修改 'age' 属性
jack.age = 8 
print("修改 'age' 属性：",getattr(jack, 'age'))
# 删除 'age' 属性
del jack.age  
print("删除 'age' 属性：",hasattr(jack, 'age'))

#编写一个名为Fruit的class，执行run()方法可以直接打印
#编写Apple和Orange类时，就可以直接从Fruit类继承
class Fruit(object):
    '父类Animal'
    def run_father(self):
        print('调用父类方法...')

class Apple(Fruit):
    '子类1 Apple'
    def run_son(self):
        print('调用子类方法...')

class Orange(Fruit):
    '子类2 Orange'
    


    
def run_son(self):
        print('调用子类方法...')
#实例化子类
apple = Apple()
orange = Orange()
#调用父类方法
apple.run_father()
orange.run_father()
#调用子类方法
apple.run_son()
orange.run_son()

class Fruit(object):
    '父类Animal'
    def run(self):
        print('调用父类方法...')

class Apple(Fruit):
    '子类1 Apple'
    def run(self):
        print('子类1 Apple 重写父类方法...')

class Orange(Fruit):
    '子类2 Orange'
    def run(self):
        print('子类2 Orange 重写父类方法...')
#实例化子类
apple = Apple()
orange = Orange()
#调用父类方法



    
apple.run()
orange.run()

# 导入模块
import math
# 现在可以调用模块里包含的函数了
print("求e的n次幂：",math.exp(1))

# from…import 语句：从模块中导入一个指定的部分到当前命名空间中
# 导入模块中的特定函数
from math import exp
# 现在可以直接使用该函数了
print("求e的n次幂：",exp(1))

# from…import* 语句：导入一个模块中的所有项目。然而这种声明不该被过多地使用
from math import *