total = item_one + \
        item_two + \
        item_three

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

print("Hello");print("Python");print("hiahiahia")

# print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
print('good','yes','hello',sep='+',end='____')		
# sep 打印时每个元素之间的连接符号,默认是空格;end 打印结束后执行的,默认是换行
print('ajf','world','asdk')

weiXinHao = input('小姐姐，可不可以把你的微信号给我：')
print(weiXinHao)
print(type(weiXinHao))		# <class 'str'>

s=0
print("变量s的地址为：{}".format(id(s)))

str="Python"

a=(1==2)	# a的值为False
b=(1<2)		# b的值为True

days=["Mon","Tue","Wed","Thu","Fri","Sat","Sun"]

person = {'name':'张三','年龄':'18','身高':'180','体重':'52kg'}

nums = (1,5,3,9,6)

x = {1,'good','hello',True}

a = 3
print(type(a))		# 输出出 a 的数据类型
print(type(3.14))	# 输出出3.14的数据类型

a = '1'
print(int(a))
b = '3.14'
print(int(b,8))		# 将b作为八进制
c = 'abc'
print(int(c,16))		# 将c最为十六进制
# 当字符串超出进制范围就会报错
 d = 'abcdefghijklmn'
 int(d,16)		# k超出16进制所以会报错

a='12.23'
print(float(a))	

# 如果字符串不能转换成为有效的浮点型，就会报错
b = 'hello'
print(float(b))

a = 24
b = str(a)

print(bool(0))		# False
print(bool(''))		# False
print(bool({}))		# False
print(bool(()))		# False
print(bool([]))		# False
print(bool(None))	# False
print(bool(set()))	# False

t = 'hello'
print(tuple(t))	# ('h', 'e', 'l', 'l', 'o')
print(list(t))	# ['h', 'e', 'l', 'l', 'o']
print(set(t))	# {'h', 'e', 'l', 'l', 'o'}

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

print('hello' + 'world')		# helloworld

print('hello' * 2)		# hellohello

print('a' < 'b')		# True
print('abc' > 'b')		# False

print('a' == 97)	# False
print('a' != 97)	# True
# print('a' > 96)	出错

a=b=c="python"		a="python";b="python";c="python"

m,n = 3,5		# m = 3		n = 5
#拆包时，变量和数据个数不一致时会报错
# m,n = 1,2,3,4
#m,n,p = 1,2

m,*n,p = 1,2,3,4,5,6		# m=1;n=[2,3,4,5];p=6
*m,n,p = 1,2,3,4,5,6		# m=[1,2,3,4];n=5;p=6

i=1
j=2
i, j = j,  i		# 交换i和j的值

x = 'hello','good','yes'	# x = （'hello','good','yes'）

x = 5
print(x << 2)		# a << n  ==>  a * (2的n次方)
print(x >> 2)		# a << n  ==>  a / (2的n次方)

print(True or False and True)		# True
print(True or (False and True))		# True	建议使用这种写法

if 判断条件：
    执行语句……
else：
    执行语句……

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

ticket = input('是否买票了Y/N')
if ticket == 'Y' :
    print('买票了，请进')
    safe = input('安检是否通过Y/N')
    if safe == 'Y' :
        print('安检通过进入候车室')
     else :
        print('进站了，安检未通过')
else :
	print('没买票，禁止入内')

if 1<=x<=5:
	……

if num1>num2:
    x = num1
else:
    x = num2
    
# 上面的分枝判断语句可以简写为：
x = num1 if num1 > num2 else num2

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

count = 0
while count < 5:
   print("{} is  less than 5".format(count))
   count = count + 1
else:
   print("{} is not less than 5".format(count))

for iterating_var in sequence:
   statements(s)

for i in [1,2,3,4]:
	print(i)

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

while expression:
   while expression:
      statement(s)
   statement(s)

break

for letter in 'Python':     
   if letter == 'h':
      break
   print("当前字母 : {}".format(letter))

continue

for letter in 'Python':     
   if letter == 'h':
      continue
   print("当前字母 : {}".format(letter))

pass

for letter in 'Python':     
   if letter == 'h':
      pass
    print("这是pass代码块")
   print("当前字母 : {}".format(letter))

def func(paras):
    pass

var1 = 1
var2 = 10
var3=1
del var1
del var2, var3

>>> number = 0xA0F # 十六进制
>>> number
2575

>>> number=0o37 # 八进制
>>> number
31

>>> 5 ** 2  # 5 的平方
25

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

import math

import random

import math

var1 = 'Hello World!'
var2="name"

变量[下标]		# 字符串中字符的访问
变量[头下标:尾下标]		# 子字符串的访问

n = 'abcdefghijklmnopqrstuvwxyz'		#第一个字符数为0, 从右向左第一个为-1
print(n[2:5])		#cde
print(n[1:9:2])		#bdfh
print(n[::-1])		#倒叙打印
print(n[-5:-2])		#vwx	step默认为1,从左向右输出
print(n[-2:-5:-1])	#yxw

>>> var1 = 'Hello World!'
>>> print ("已更新字符串 : ", var1[:6] + 'Runoob!')
已更新字符串 :  Hello Runoob!

f = '你好\n世界'	# 这样会打印你好后会换行
g = r'你好\n世界'	# 这样打印就不会换行,而是直接全部原样输出'你好\n世界'

>>> print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!

# 使用空{}占位,顺序填入
print('大家好,我是{},今年{}岁,来自{}'.format('张三', 18, 'Handan'))		# 注意format前面是.点
# 输出为：大家好，我是张三，今年18岁，来自Handan

# 使用{数字}占位,按照数字顺序填入,从0开始
print('大家好,我是{2},今年{0}岁,来自{1}'.format(18, 'Handan', '张三'))
# 输出为：大家好，我是张三，今年18岁，来自Handan

# 使用{变量名}占位
print('大家好,我是{name},今年{age}岁,来自{home}'.format(name='张三',home = '邯郸', age=18))
# 输出为：大家好，我是张三，今年8岁，来自邯郸

#{数字}和{变量名}可以混合使用,要求变量要放在最后
print('大家好,我是{1},今年{age}岁,来自{home},今天挣了{0}元'.format(88,'张三',home='Handan',age=18))
# 输出为大家好，我是张三，今年18岁，来自Handan，今天挣了88元

#空{}和{变量名}可以混合使用,要求变量要放在最后
print('大家好,我是{},今年{age}岁,来自{home},今天挣了{}元'.format('张三',88,home='Handan',age=18))
# 输出为大家好，我是张三，今年18岁，来自Handan，今天挣了88元

#空{}和{数字}不能混合使用

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

# 输出结果为：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

x = ['h','e','l','l','o']
print(x.index('o'))			# 4
# print(x.index('t'))
print(x.count('l'))			# 2
print('h' in x)				# True
print('k' in x)				# False

shooter = ['后羿', '黄忠', '虞姬', '公孙离', '狄仁杰','孙尚香', '李元芳','百里守约', '鲁班七号']
i = 0
while i < len(shooter)
	print(shooter[i])
    i++

shooter = ['后羿', '黄忠', '虞姬', '公孙离', '狄仁杰','孙尚香', '李元芳','百里守约', '鲁班七号']
#for..in..的本质是调用面向对象的next方法
for i in shooter
	print(i) 
# 使用内置函数enumerate()进行带下标的遍历
for i, people in enumerate(shooter): 
    print('第%d个是%s' % (i,people))

x = [10,20,30]
y = x	# y 和 x 指向同一个内存地址
x[0] = 1	# 修改 x ,y也会随着改变

x = [10,20,30]
z = x.copy()	# y 和 x 指向不同内存地址
x[0] = 1		# 修改 x ,z不会随之改变

import copy
x = [10,20,30]
a=copy.copy(x)	#效果等价于copy方法,都是一个浅拷贝
x[0]=1			# 修改x,y 不会改变

x = [10,20,30]
y = x[:]		# 切片也是一个浅拷贝
x[0] = 1		# 修改x,y 不会改变

nums = [5,9,3,4,7,0,2,1,6,8]
nums.sort()		#默认为正序
print(nums)
nums.sort(reverse=True)		#添加 reverse=True 参数为逆序
print(nums)

nums = [5,9,3,4,7,0,2,1,6,8]
x = sorted(nums)
print(nums)
print(x)

names = ['张三','李四','王五']
names.reverse()
print(names)

names = ['张三','李四','王五']
print(names[::-1])

x = [i for i in range(10)]
pront(x)		# [0,1,2,3,4,5,6,7,8,9]

t = [i for i in range(10) if i % 2 == 0]
print(t)		# [0,2,4,6,8]

# points 是一个列表,里面元素都是元组
points = [(x,y) for x in range(5,10) for y in range(10,20)]		# for语句是嵌套的
print(points)		# 共有 50 个元素

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

# 创建空元组
tup4 = ()

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2

# 创建元组
tup = ('Google', 'Runoob', 1997, 2000)

# 删除整个元组
# 此时若对元组进行输出，会报错，提示tup未定义
del tup

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
tup[1]		# 'Runoob'	读取第二个元素
tup[-2]		# 'Weibo'	反向读取，读取倒数第二个元素
tup[1:]		# ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')	截取元素，从第二个开始后的所有元素。
tup[1:4] 	# 	('Runoob', 'Taobao', 'Wiki')	截取元素，从第二个开始到第四个元素（索引为 3）。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
    
    
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

d = {key1 : value1, key2 : value2, key3 : value3 }

# 使用大括号 {} 来创建空字典
emptyDict = {}

# 使用内建函数dict()创建空字典：
emptyDict = dict()

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Alice']: ", tinydict['Alice'])


# 报错内容
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

person = {'name': 'zhangsan', 'age': 18,'x':'y'}
print(person.get('name'))


# 如果 key 不存在,会默认返回 None,而不报错
print(person.get('whit'))	# None


# 如果 key 不存在,可以返回给定值
print(person.get('geter','falge'))	# falge

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
# 使用key修改对应的value
tinydict['Age'] = 8      

# 添加新的键值对
tinydict['day'] = "Wed"  

person1 = {'name': 'zhangsan', 'age': 18}
person2 = { 'heighe': 185, 'whit': 65}
person1.update(person2)
print(person1)		

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典


person = {'name': 'zhangsan', 'age': 18, 'heighe': 185, 'whit': 65}
print(person.pop('age'))	# 把key对应的键值对删除了,并返回value值
print(person.popitem())		# 删除一个键值对,并返回一个由该键值对组成元素的元组

person = {'name': 'zhangsan', 'age': 18, 'heighe': 185, 'whit': 65}
# 字典遍历
# 方法一:
for k in person:  # k 获取的是 key
    print(k, ':', person[k])
    
    
# 方法二:
print(person.keys())  # dict_keys(['name', 'age', 'heighe', 'whit'])
for k in person.keys():  # keys() 方法是获取字典的key
    print(k, ':', person[k])
    
    
# 方法三:
print(person.values())  # dict_values(['zhangsan', 18, 185, 65])
for v in person.values():  # 使用 values() 方法获取字典的value
    print(v)  # 只能打印 value
    
    
# 方法四:
print(person.items())	# items() 方法获取的是字典的键值对
# dict_items([('name', 'zhangsan'), ('age', 18), ('heighe', 185), ('whit', 65)])
for k, v in person.items():  # 利用了拆包方法
    print(k, ':', v)
'''常用方法一和方法四'''

# 交换key,value
person = {'name': 'zhangsan', 'age': 18, 'heighe': 185, 'whit': 65}

# 方法一:
person1 = {}
for k,v in person.items():
    person1[v] = k
person = person1


# 方法二:推导式
person={v:k for k,v in person.items()}  # 交换key和value
print(person)

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}


>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False


>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}


>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}

>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}

>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

s.add( x )
# 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

# 参数可以是列表，元组，字典等迭代对象
s.update( x )

# x 可以有多个，用逗号分开。
thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

# 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
s.remove( x )

# 如果元素不存在，不会发生错误
s.discard( x )

# 随机删除集合中的一个元素
s.pop()

# 清空集合 s。
s.clear()

# 计算集合 s 元素个数。
len(s)

# 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
x in s

def 函数名（参数列表）:
    函数体

# 返回两数中的较大者
def max(a, b):
    if a > b:
        return a
    else:
        return b

# 先定义函数
def max(a, b):
    if a > b:
        return a
    else:
        return b
        
# 再调用函数
maxValue=max(1,2)

# 函数定义
def add(a,b):	# 此 a,b 就是形参
    c = a + b
	return c
# 调用
print(add(1,2))	# 1和2 为实际给出的故为实参

a=[1,2,3]

a="Python"

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)


'''
输出结果：
4379369136
4379369136
4379369424
'''

# 可以看出在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，函数内部的a和外部的a的对象 id 不同了，表明此时函数内部的 a 是一个新的对象。

def changeme( mylist ):
   # 修改传入的列表
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)


'''
输出结果：
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
'''

#  可变对象在函数里被修改了，在这个函数外部，对象内容也被修改了，表明函数内部和函数外部的 mylist 是同一个对象。

# 定义函数，这里printme 函数只有一个参数，并且为必需参数
def printme( str ):
   print (str)
   return
 
# 调用函数，不加参数会报错
printme()

'''
程序报错：
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'
'''

def printinfo( name, age ):
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="python" )

'''
输出结果：
名字:  python
年龄:  50
'''


def add(a,b,c,d):	# 此 a,b 就是形参
    sum = a + b	+ c + d
	return sum
# 调用
print(add(1,2,d=4,c=3))	# 1,2为位置参数顺序传递给a,b;d=4,c=3为关键字参数,传递给对应形参d,c
# 注意:如果c为关键字参数,则之后的所有参数都必须为关键字参数

# print 就是一个包含缺省参数的函数，sep 参数和 end 参数就有默认值，调用的时候若没有给定这两个参数值，默认用空格连接,结束为换行
print('hello','world',sep = '+',end = '')	# 默认用空格连接,结束为换行



# 定义缺省参数, 直接在参数后面给定默认值即可
def introduce(name, age, monthly_income='1w'):	# 缺省参数必须放在最后面
    print('大家好,我是{},今年{}岁,月入{}元'.format(name, age, monthly_income))


introduce('张三', 25)			# 大家好,我是张三,今年25岁,月入1w元
introduce('李四', 24, '9k')	# 大家好,我是李四,今年24岁,月入9k元

def functionname([formal_args,] *var_args_tuple ):
   function_suite
   return [expression]

# 可变位置参数
def add(a, b, *args):	# 如果有缺省参数应放在*arge后面,如: def add(a, b, *args, num1=10):
    c = a + b
    for arg in args:
        c += arg
    return c


print(add(1, 2, 3, 4, 5, 6, 7))     # 1,2传递给a,b 剩下数据以元组的形式传递给args

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

def functionname([formal_args,] **var_args_dict ):
   function_suite
   return [expression]

def add(a, b, *args,num1=10,**kwargs):
    c = a + b
    for arg in args:
        c += arg
    return c

print(add(1, 2, 3, 4, num1=3, x=5, y=6))	#  1,2传递给a,b，之后直到 num=3 之间的参数以元组的形式传递给args，最后剩下的参数以字典的形式传递给 kwargs（kwargs中的内容为：['x':5,'y':6]）

def add(a,b):
    c = a +b
    return c	# 将c返回给主调函数
t = add(1,2)
print(t)

# 一般情况下函数只执行一个return
# 特殊情况（finally语句）下，一个函数可能执行多个return语句
def test(a, b):
    x = a // b
    y = a % b
   # return x		# return语句表示一个函数的结束
	# return y		# 所以不会执行到此行
	return x, y		# return返回的实质是一个元组，但是小括号()可以省略,等价于 return (x, y)

	return [x, y]	# 可以返回一个列表
	return {'x':x, 'y':y}	# 也可以返回一个字典


shang, yushu = test(32,6)	# 元组拆包
print('商是{}，余数是{}'.format(shang, yushu))

def add(a, b):

    c = a + b
    return c



# 在Python里的函数参数类型不会被限制
print(add('hello', 'world'))	


# 但是我们可以给使用建议数据类型
def acc(a: int, b: int):
    c = a * b
    return c


print(acc('hello', 4))		# 一般'hello'会有警告提示，但不会报错

lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)		# mydoubler=lambda a:a*2
mytripler = myfunc(3)		# mytripler=lambda a:a*3
 
print(mydoubler(11))		# 22
print(mytripler(11))		# 33

# 调用一个函数,完成多种运算
def calc(a, b, fn):
    c = fn(a, b)
    return c
	

def add(x, y):
    return x + y


def mul(x, y):
    return x * y


calc(4, 3, add)  # 将函数名作为参数
calc(5, 7, mul)



# 当函数表达式比较简单时,可以使用匿名函数
# 把匿名函数作为函数参数
print(calc(21, 7, lambda x, y: x / y))

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    
# 形参 a 和 b 必须使用指定位置参数，c 和 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def fact(n):  # 求n的阶乘
    t = 1
    for i in range(1, n + 1):
        t *= i
    return t


def fac_sum(m):		# 求阶乘的和
    x = 0
    for i in range(1, m + 1):
        x += fact(i)		# 函数调用函数
    return x

print(fac_sum(5))

# 使用递归调用，实现快排
def quick_sort(data):
    if len(data) >= 2:  # 递归入口及出口
        mid = data[len(data) // 2]  # 选取基准值，也可以选取第一个或最后一个元素
        left, right = [], []  # 定义基准值左右两侧的列表
        data.remove(mid)  # 从原始数组中移除基准值
        for num in data:
            if num >= mid:
                right.append(num)
            else:
                left.append(num)
        return quick_sort(left) + [mid] + quick_sort(right)		# 递归调用
    else:
        return data		# 递归出口		递归结束条件：len(data)<2


'''
array = [2, 3, 5, 7, 1, 4, 6, 15, 5, 2, 7, 9, 10, 5, 9, 17]
print(quick_sort(array))
# 输出为[1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7, 9, 9, 10, 15, 17]
'''

def say_story():
    print('老头和小伙讲故事')
    print('讲故事的是')
    say_story()				# 这样会陷入死循环,导致报错
    
say_story()

# 全局变量,在整个py文件里都可以使用
a = 14  
word = '你好'



# 在Python里,只用函数能分割变量作用域
def test():  
    x = 'ok'  # 定义在函数内部的变量为局部变量,只能在函数内度使用

    # 如果函数内变量的名和全局变量同名,会在函数内定义一个新的变量,而不是修改全局变量,即在函数作用域内，将同名全局变量屏蔽了
    a = 10
    print('函数内部a={}'.format(a))

    # 使用global进行对外部变量声明,进行修改全局变量
    # 通过global的声明，取消了对 word 的屏蔽，这里使用和外部的 word 是同一个
    global word
    word = 'hello'

    # 使用内置函数 locals()查看局部变量, globals()查看全局变量
    print('locals={},\nglobals={}'.format(locals(), globals()))


test()
# print('x={}', format(x))      #函数外部不能使用函数内部的变量，会报错，变量未定义
print('函数外部a={}'.format(a))
print('函数外部word={}'.format(word))

def test():
    print('我是test函数')
    return 'hello'

def bar():
    print('我是bar函数')
    
    # 在这里返回的是对test 函数的调用，书架上是在 bar 函数结束之前对test 函数调用了一次，bar返回的是test函数的返回值
    return test()	# 返回的是函数,即调用函数	

def demo():
    print('我是demo函数')
    return test		# 返回的是变量名,可以作为字符串被python解析

# 调用 函数 bar ，实际上运行了bar函数一遍，并且还运行了一遍 test 函数
bar()
'''
输出结果：
我是bar函数
我是test函数
'''

# 将 函数 bar的返回值赋给 x，并执行了一遍 bar函数
# x中存放的是test的返回值，字符串"hello"，x类似于一个宏
x=bar()
print(x)
'''
输出结果：
我是bar函数 
我是test函数
'''

# demo()()先执行一遍函数demo，之后变成 test()，再执行一遍函数 test()
demo()()
'''
输出结果：
我是demo函数
我是test函数
'''

先执行一遍demo函数，此时y相当于一个宏，内部存放的是字符串常量 "test"，之后再执行一遍函数 test
y = demo()
y()
'''
输出结果：
我是demo函数
我是test函数
'''

def data():
    print('data被被打印了')
    def lanm():
        print('lanm被打印了')
    return lanm()

'''
输出结果：
data被被打印了
lanm被打印了
'''

def outer():
    x = 10		# 在外部函数定义了一个变量x,为一个局部变量
    y = 30
    def inner():	
        x = 20	# 不是修改外部变量x,而是在内部函数创建了一个新的变量x
        z = y + 1	# 可以直接使用外部函数变量,但是不能修改
        # 在内部函数用 nonlocal 声明外部函数变量
        nonlocal y
        y = 10	# 此时是修改外部函数变量y
    return inner	# 返回的是 inner 函数首地址,加小括号才能调用


# outer()() 相当于是 inner()
outer()()		# 先返回的是 inner ,加上()后是调用

#闭包函数，其中 exponent 称为自由变量
def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是 exponent_of 函数


square = nth_power(2) # 计算一个数的平方，square是一个函数指针
cube = nth_power(3) # 计算一个数的立方，cube是一个函数指针
print(square(2))  # 计算 2 的平方，相当于 nth_power(2)(2)
print(cube(2)) # 计算 2 的立方，相当于 nth_power(3)(2)


def nth_power_rewrite(base, exponent):
    return base ** exponent



# 不使用闭包
res1 = nth_power_rewrite(base1, 2)
res2 = nth_power_rewrite(base2, 2)
res3 = nth_power_rewrite(base3, 2)


# 使用闭包
square = nth_power(2)
res1 = square(base1)		# 相当于 nth_power(2)(base1)
res2 = square(base2)		# 相当于 nth_power(2)(base2)
res3 = square(base3)		# 相当于 nth_power(2)(base3)

def function_name(fn):
    def inner():
        pass
    
    return inner

# 在不改变 demo 函数源码的条件下，为 demo 函数添加了 function_name 函数中的功能
@function_name		# 用来装饰deom函数
def deom():
    pass

import time


def cal_time(fn):
    def inner():
        start = time.time()
        t = fn()
        end = time.time()
        print('程序耗时', end - start)
        return t

    return inner


@cal_time  		#第一件事调用cal_time;	第二件事把被装饰的函数传给fn;
def dome():		# 第三件事返回inner给dome,即dome=inner(dome指向inner函数首地址)
    for i in range(1,100000000):
        i += i
    return i

# 第四件事当再调用dome时,此时的dome函数不再是上面的dome,而是inner+demo
print('装饰后的dome={}'.format(dome))
# 装饰后的dome=<function cal_time.<locals>.inner at 0x00000281704D83A0>
dome()

# 提需求/改需求

def wegame(name,game):
    print('{}在玩{}'.format(name,game))
    
wegame('张三','王者荣耀')

# 该需求,在22点后不能玩了
# 一般我们不会在原函数上修改了
def funct(fn):
    def inner(x,y,time):
        if time>=22:
            ptint('太晚了,不能打游戏了')
         else:
            fn(x,y)
    
    return inner


@funct
def wegame(name,game):
    print('{}在玩{}'.format(name,game))
    
wegame('张三','王者荣耀',time=23)

import time		# 使用 	import 模块名 		直接导入
time.time()		# 模块名.函数名 	使用模块里的函数
time.sleep(3)	# 可以使用模块里所有的函数或变量

from random import randint		# 使用	 form 模块名 import 函数名/子包名 	导入模块里一个函数或变量
randint(0,2)	# 直接使用且只能使用这一个函数

from math import *		# 使用 	form 模块名 import * 		导入模块里所用函数和变量

# 可以直接使用模块里所有函数和变量
print(pi)	
abs(-4)		

import datetime as dt	# 导入一个模块,并起一个别名
dt.MAXYEAR		# 使用别名代替原模块名

from copy import deepcopy as dp		# 导入模块里一个函数或变量,并起一个别名
dp(['hello','good'[1,5,9],'yes'])

# 也可以一次导入多个模块，多个模块之间用逗号隔开。
# 导入sys、os两个模块
import sys,os


# 导入sys、os两个模块，并为sys指定别名s，为os指定别名o
import sys as s,os as o


# 导入sys模块的argv,winver成员
from sys import argv, winver


# 导入sys模块的argv,winver成员，并为其指定别名v、wv
from sys import argv as v, winver as wv

from modname1 import *
from modname2 import *
from modname3 import *

# 这样写代码的时候，代码中的变量会变得非常混乱。不仅仅是后面导入的同名函数会覆盖前面的问题，而且导致在写一个函数的时候不能确定它到底来自哪里，代码可读性会变得非常差。


# 建议尽量这样写
import modname1
import modname2
import modname3

modname1.def1()
modname2.def1()
modname3.def1()
# 这样不仅不会找不见同名函数，也可以非常确切的看到这个函数来自哪里


# 如果库一层套一层，是这样的结构：
import path1.path2.path3.modname1
# 可以用as关键字给它重命名，以便于缩短代码宽度，维持可读性
import path1.path2.path3.modname1 as pm

import os

# 返回正在使用的平台。如果是windows则用‘nt’表示，对于linux/unix用户则用'posix'表示。
os.name		

# 返回当前python脚本工作的目录路径。
os.getcwd()		
# 返回一个当前工作目录的Unicode对象
os.getcwdb()
# 获取当前目录的父目录，以字符串形式显示目录名。
os.pardir()

# 获取环境配置
os.environ	
# 获取指定环境配置
os.environ.get('PATH')	

# 返回指定目录下的所有文件和目录名，括号里如果调用函数则不用双引号或单引号，如果是传入一个路径，则必须要用双引号或单引号将变量标识为一个整体，否则报错。括号内可以：1）调用函数 2）传入参数（即路径）
os.listdir()	

# 重命名
os.rename(name,name1)	
# 删除一个文件，括号里必须是文件的指定路径
os.remove("文件路径")   
# 删除空文件夹
os.rmdir('文件夹路径')	
 # 删除空文件夹
os.removedirs('文件夹路径')	
# 创建一个文件夹
os.mkdir()		

# 运行shell命令
os.system("shell命令")	

# 改变当前脚本的工作目录,相当于shell下的cd命令
os.chdir(path)		
# 返回上级目录
os.chdir('../')	

# 取代操作系统特定的路径分隔符，python是跨平台的，在windows上，文件的路径分隔符是'\'。为了让代码在不同的平台上上都能运行，使用os.sep会根据你所处的平台，自动采用相应的分隔符号。
os.sep()		

# 返回当前平台使用的行终止符，Linux使用'\n', windows使用'\r\n', mac使用'\r'.
os.linesep()		

# 获取文件的属性信息。
os.path 模块
# 返回一个路径的目录名和文件名
os.path.split()		
# 检验给出的是否为文件
os.path.isfile()	
# 检验给出的是否为文件夹	
os.path.isdir() 		
# 检验给出的路径是否真实存在
os.path.exists()		
# 获得文件的绝对路径
os.path.abspath(name)	
# 规范path字符串形式
os.path.normpath(path)		
# 获取文件大小(字节); 在没写文件的路径的时候,默认的是当前的工作路径
os.path.getsize(name)	
# 分离文件名与扩展名
os.path.splitext()		
# 连接目录与文件名或目录
os.path.join(path,name)		
# 返回文件名，不包含拓展名
os.path.basename(path)		
# 返回文件路径
os.path.dirname(path)		

# 更改权限
os.chmod(path,flags)
# 更改文件所有者
os.chown(path,uid,gid)

# 改变当前进程的根目录
os.chroot(path)

# 关闭文件描述符 fd
os.close(fd)
# 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
os.closerange(fd_low,fd_high)
# 复制文件描述符 fd
os.dup(fd)
# 将一个文件描述符 fd 复制到另一个 fd2
os.dup2(fd,fd2)
# 通过文件描述符改变当前工作目录
os.fchdir(fd)
# 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
os.fchmod(fd,mod)
# 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
os.fchown(fd,uid,gid)
# 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
os.fdatafsync(fd)
# 强制将文件描述符为fd的文件写入硬盘。
os.fsync(fd)

# 打开一个文件，并且设置需要的打开选项，mode参数是可选的
os.fopen(file,flags[,mode])
# 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
os.pipe()
# 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
os.read(fd,n)

# 删除文件路径
os.unlink(path)

# 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
os.write(fd,str)

import sys
print(sys.path)		# 返回一个列表,列出查找模块的所有路径
sys.argv		# 传递给Python脚本的命令行参数列表
sys.exit()		# 程序退出,和内置函数exit功能一样

sys.stdin		# 接收用户输入
sys.stdout		# 标准输出, 改变默认输出位置(如:输出到一个文件里)
sys.stderr		# 改变错误输出的默认位置

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757

>>> math.log(1024, 2)
10.0

>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'

>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]

>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'


>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

import time		# 导入时间模块
start = time.time()		# 获取当前时间戳
#时间戳就是格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起到现在的总秒数

time.sleep(3)	# 延时3秒
time.localtime(start)	# 格式化时间戳为本地时间, 返回一个时间元组

time.asctime(time.localtime(start))	#接受一个时间元组并返回一个可读的形式


time.ctime([secs])	# 需要一个时间戳,如果没有则返回计算机时间	
time.gmtime()	# 返回一个格林威治天文时间下的时间

end=time.time();

lenTime=end-start		# 单位为秒

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41

>>> t = zlib.compress(s)
>>> len(t)
37

>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

>>> 'tea for too'.replace('too', 'two')
'tea for two'

>>> from urllib.request import urlopen
>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     line = line.decode('utf-8')  # Decoding the binary data to text.
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print(line)

<BR>Nov. 25, 09:43:32 PM EST

>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()

import hashlib

# 需要将加密的内容转化为二进制
x=hashlib.md5()		# 生成一个md5对象
x.update('123'.encode('utf8'))
print(x.hexdigest())

# hmac模块也是一种单向的加密算法,并且它是基于各种哈希算法/散列算法,
# 只是它可以在运算的过程中,使用一种密钥来增强安全性,hmac模块实现了HAMC算法,
# 提供了相应的函数和方法,且与hashlib提供的api基本一致.
import hmac

h = hmac.new(bytes('secret_key','utf8'),bytes('ssssddddddd','utf8'),hashlib.sha1)
#第一个参数是密钥key，第二个参数是待加密的字符串，第三个参数是hash函数
# Python3 key和带加密字符串需转换为bytes类型,且需要utf8编码
result = h.hexdigest()
print(result)

# 下载安装第三方库
pip install <库名>		

# 卸载第三方库
pip uninstall <库名>		

# 列出当前环境安装了哪些模块和版本号
pip list		

# 列出当前环境安装了哪些模块和版本号
pip freeze		

# 重定向,即将安装的库及对应的版本号放到 requirements.txt文件里
pip freeze > requirements.txt		

# 读取并安装文件里的库
pip -r install requirements.txt		

# 临时从指定网站下载
pip install <库名> -i <网址> 		

__all__ = ['m', 'date']
'''from <模块名> import * 语法只能调用__all__列表包含的变量和函数,
如果没有__all__才会导入所有的变量和函数,但不能导入以一个下换线开始的变量和函数'''

m = 'hello'
a = 1000


def date():
    print('我是模块里的name')


# 约定俗成: 以一个下划线开始的变量和函数只在本模块内部使用,不建议外部调用,如果强行调用可能会崩
_x = 'world'  # 使用 from <> impport * 语法无法调用以一个下划线开始的变量和函数，通过不将 _x放入 __all__来保证使用 import * 不会导入 _x



def _qute():
    print('我是_qute函数')
    
def division(a,b):
    return a/b


# __name__当直接运行py文件时,值是__main__
# 如果这个py文件作为模块导入时,值是文件名
if __name__=='__main__':       # 使用次语句可以检测模块里的函数,而在调用时不执行以下内容
    print('模块里的name是:',__name__)    # 模块里的name是: __main__
    print('测试一下 division 函数,结果是:',division(4,2))


# 在最后使用del函数删除变量和函数,即使外部强行调用也会崩,没有删除的可以调用
# 约定俗成:只删除以一个下划线开始的变量和函数
del (_x)

# 列表创建迭代器
>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
    
    
'''
输出结果：
1 2 3 4
'''

import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()
        
'''
输出结果：
1
2
3
4
'''

# 使用 yield 实现斐波那契数列：
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
        
'''
输出结果：
0 1 1 2 3 5 8 13 21 34 55
'''

open(file, mode='r')	# 以只读方式打开文件。文件的指针将会放在文件的开头。这也是默认模式。

# open函数的完整参数
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

'''
参数说明：
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
'''

# 将字符串写入到文件 foo.txt 中
# 打开一个文件
f = open("{}/foo.txt".format(path), "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

[表达式 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]

# 过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']