#example 1
#字符串逆序
str=input('请输入一个字符串：')
print("原串：",str)
print("逆串：",str[-1::-1])
#以下使用字符串格式化输出
print("原串：%s"%(str))
print("逆串：%s"%(str[-1::-1]))
print("今年是%d年%d月%d日，天气%s!"%(2017,1,1,'晴')) #格式化字符串输出例子
'''
运行结果：
请输入一个字符串：123456
原串： 123456
逆串： 654321
原串：123456
逆串：654321
今年是2017年1月1日，天气晴!'''
#example 2
#统计文中单词出现的次数
passage='Do not trouble trouble till trouble troubles you.'
word=input("输入想查找的词：")
n=passage.count(word)
print('%s出现的次数为：%s'%(word,n))
'''
运行结果：
输入想查找的词：trouble
trouble出现的次数为：4'''
#example 3
#函数的调用——求阶乘问题
def fun(x):
n=1
for i in range(1,x+1):
n=n*i
return n
y=int(input('输入一个正整数：'))
if y<0:
print("输入错误！")
else:
print("%d的阶乘为%d"%(y,fun(y)))
'''
输入一个正整数：5
5的阶乘为120'''
#example 4
#参数传递方式
'''传递不可变对象(元组，一般变量)，形参的变化不会影响到实参'''
def add(x):
print("形参x的初始值是:",x) #形参x的初始值是: 4
x+=1
print("形参x的最终值是:",x) #形参x的最终值是: 5
y=4
add(y)
print("实参y的值是：",y) #实参y的值是： 4
'''传递可变对象(如列表，字典等)，形参的变化会影响到实参'''
#列表作实参
def change(v):
v.append(3)
print("形参最终值：",v) #形参最终值： [1, 3]
list1=[1]
print("实参初始值：",list1) #实参初始值： [1]
change(list1)
print("实参最终值：",list1) #实参最终值： [1, 3]
#字典作实参
def change(v):
v['姓名']='诸葛亮'
v['性别']='男'
v['年龄']=59
dict1={'姓名':'林黛玉','性别':'女','年龄':20}
print("初始字典：",dict1) #初始字典： {'姓名': '林黛玉', '性别': '女', '年龄': 20}
change(dict1)
print("最终字典：",dict1) #最终字典： {'姓名': '诸葛亮', '性别': '男', '年龄': 59}
#位置参数和关键字参数
#调用位置参数时，要求参数的个数，位置和顺序要与定义中的形参一致，--对应
#关键字参数明确指定参数值传递给哪个形参
'''比如函数头是这样：def fun(a,b)
fun(100,200)与fun(200,100)是不同的 --->未知参数
fun(a=100,b=200)与fun(b=200,a=100)是一样的 --->关键字参数'''
#默认值参数
#默认值要求定义函数时必须保证必选参数在前，默认值参数在后
#此外，需要注意的是：默认值参数必须指向不可变对象，避免造成程序错误
'''比如函数头是这样：def fun(x,y=4,z=5)
fun(3)与fun(7,8,9)都是可以的，前者使用默认值'''
#可变参数
#可变参数的产生背景：有时并不能事先确定函数到底需要多少个参数，而可变参数可以接收任意多个参数
#单星号参数——接收元组
#example 5
#求输入实参的平方和
def fun(*x):
print(type(x))
print("可变参数的值为：",x)
sum=0
for i in x:
sum=sum+i*i
print("平方和为：",sum)
return sum
fun(1,2,3)
fun(1,2,3,4)
fun()
'''
运行结果：
<class 'tuple'>
可变参数的值为： (1, 2, 3)
平方和为： 14
<class 'tuple'>
可变参数的值为： (1, 2, 3, 4)
平方和为： 30
<class 'tuple'>
可变参数的值为： ()
平方和为： 0'''
#双星号参数——接收字典
#example 6
def fun(x,**y):
print(type(y))
print("y:",y)
print("x",x)
for i in y:
print(i+':'+str(y[i]))
fun("985高校",a="大连理工大学",b="东北大学",c="四川大学")
'''
运行结果：
<class 'dict'>
y: {'a': '大连理工大学', 'b': '东北大学', 'c': '四川大学'}
x 985高校
a:大连理工大学
b:东北大学
c:四川大学
'''
#参数传递时序列解包
'''对于刚才的求可变参数平方和的那个函数，我们已知它会将输入的序列转换成一个元组
但是如果被传递的实参是像列表这样的复合数据类型时，直接传递[1,2,3,4]必然会导致错误
因为会将其转换成([1,2,3,4]),这个表达式是无法求其平方的
但我们知道，我们想真正求的是列表中各个元素的平方和，其实可以这样暴力实现：
fun(list[0],list[1],list[2])，这样太繁琐，那么有什么机制可以将这些复合类型拆解成元素，
答案是有的，序列解包就可以解决这个问题。用法：对于序列型的实参，可以在前面添加一个星号，会将
实参序列进行解包
'''
def fun(*x):
print(type(x))
print("可变参数的值为：",x)
sum=0
for i in x:
sum=sum+i*i
print("平方和为：",sum)
return sum
list1=[1,2,3,4]
fun(list1) #TypeError: can't multiply sequence by non-int of type 'list'
#可变参数的值为： ([1, 2, 3, 4],)
fun(*list1) #平方和为30
#可变参数的值为： (1, 2, 3, 4)
#再举个栗子，更直观说明
def add_three(x,y,z):
s=x+y+z
print(s)
list1=[1,2,3]
tuple1=(1,2,3)
dict1={1:'x',2:'y',3:'z'}
set1={1,2,3}
'''若实参为复合数据类型，将实参解包后进行参数传递'''
add_three(*list1) #6
add_three(*tuple1) #6
add_three(*dict1) #6
add_three(*set1) #6
#example 5
#函数的返回值:与其他高级变量如c,c++的使用是一样的
def min(x,y):
if x<y:
return x
else:
return y
print(min(1,3)) #打印1
#example 6
#变量的作用域
a,b=3,6 #主程序中定义的变量全是全局变量
def fun():
global a #a是全局变量，与主程序中的a为同一变量
a=10
b=20 #b定义在函数体内赋值语句等号左侧，是局部变量，与主程序中的b不一样
c=a*b #c是局部变量
print(a,b,c) #10 20 200
fun()
print(a,b) #10 6
#example 7
#函数的嵌套
def first():
x1="Dream1" #first()函数内局部变量x1，可用在first函数内及其嵌套子函数
print(x1) #Dream1
def second():
x1="second_Dream1" #此x1是函数second的局部变量，与first的x1不同
global x2 #x2是全局变量，作用域为整个程序
x2="Dream2"
print(x1,x2) #second_Dream1 Dream2
def third():
x2="third_Dream2" #此x2是third函数内的局部变量，与second内定义的全局变量不同
x3="Dream3" #同理，x3是third内的局部变量
print(x1,x2,x3) #second_Dream1 third_Dream2 Dream3
return third()
second()
print(x1,x2) #Dream1 Dream2（注意：全局变量x2没有被改动，third里的x2根本不是全局变量）
first()
'''
运行结果
Dream1
second_Dream1 Dream2
second_Dream1 third_Dream2 Dream3
Dream1 Dream2'''
#example 8
#lambda函数和递归(求斐波那契第N项)
f=lambda x,y=3,z=5:x+y+z #又称匿名函数，用法：<函数名>=lambda <参数列表>：<表达式>
print(f(4),f(4,5,6)) #12
def fib(n): #斐波那契函数
if n<2:
return n #递归终止条件
else:
return fib(n-1)+fib(n-2) #递归式
print(fib(5)) #5
print(fib(8)) #21
