Python初识（一）

if inputNum > luky_num:
print("the real number is smaller...")

str = '''
Hello, welcoming Python Word!
wall, please ask me question。
start ..'''
print(str)

msg = "" # 变量定义
if (a > b) : # 条件判断
msg = 'a 大于 b' # 变量赋值
elif(a == b): # 条件判断
msg = 'a 和 b一样大' # 变量赋值
else:
msg = 'a 小于 b' # 变量赋值 print(msg) # 输出变量

print(1 if 2 > 3 else 6) # 若条件成立输出1，否则输出6

sex = input("您是man or girl？(请输入man or girl？)") if sex is "girl":
print("I would like to have a limit monkey. ")
elif sex is "man":
print("I like MM.")
else:
print("Pervert! you are Pervert!")

'''
小游戏：—— 猜数字
每个人都有一个幸运数字。
猜对它，不管对与错，只有3次机会
''' luckyNum = 19 # 幸运数字
CI = 3 # 共有3此机会
curCi = 0 # 当前次数 while True:
inputNum = int(input("请输入您的幸运数字（共有" + CI + "次机会，还有" + str(CI-curCi) + "次机会哦^_^）："))
curCi += 1
if luckyNum == inputNum:
print("bingo！结束")
break
elif luckyNum > inputNum:
print("The number is big, this number is smaller.")
else:
print("The number is small,this number is bigger.")

# 求素数

for a in range(2, 101): # 求2~100的素数

for i in range(2, int(a**0.5)):

if a % i == 0:

break

else:

print(a)

print('''
计算 X^n 的值
''')def power(x, n = 2): # 参数有默认值
s = 1
while n > 0:
n = n - 1
s = s * x return sprint(power(2))
print(power(2,2))
print(power(2,3))
print(power(2,4))
print(power(2,5))

print(
'''
给定一组数字a，b，c……，请计算a^2 + b^2 + c^2 + ……
'''
)def calc(*number): # 可变参数(任意参数)
sum = 0
for n in number:
sum += n * n return sumprint(calc(*[1,2,3]))
print(calc(*(1,2,3)))
print(calc(1,2,3))

# 利用lambda来充当匿名函数
# lambda 格式:封号之前是参数列表，封号之后是函数体
print('求X^^2:',list(map(lambda x:x*x,range(1,10))))f = lambda x:x*x
print(f(5))

print('''
\b高阶函数英文叫Higher-order function。参数是函数的函数叫高阶函数（强大之处）
''')print(abs(-10))print('函数本身也可以赋值给变量，即：变量可以指向函数。')
f = abs
print(f)print('函数名也是变量:')abs = 10
# print(abs(-10)) # 报错print('传入函数：')def add(x,y ,f): return f(x) + f(y)print(add(-2,3,f))print('把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。')

def lazySum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum f = lazySum(1,3,5,7,9)
print(f)
print(f())print('''
在这个例子中，我们在函数lazy_sum中又定义了函数sum，
并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，
当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，
这种称为“闭包（Closure）”的程序结构拥有极大的威力。
''')f1 = lazySum(1,3,5,7,9)
f2 = lazySum(1,3,5,7,9)
print(f1 == f2) # 闭包每次返回一个新的函数print('''
eg1:
''')def count():
fs =[]
for i in range(1,4):
def f():
return i * i
fs.append(f)
return fsf1,f2,f3 = count()
print('f1() = %s, f2() = %s, f3() = %s' %(f1(), f2(), f3()))print('''
eg2:
''')def count2():
def f(j):
def g():
return j * j
return g
fs =[]
for i in range(1,4):
fs.append(f(i)) # f(i)被立即执行，因此传入的是i的当前值
return fsf21,f22,f23 = count2()
print('f21() = %s, f22() = %s, f23() = %s' %(f21(), f22(), f23()))

print(int('123456')) # str————>int 十进制（默认）
print(int('123456', base=8)) # str————>int八进制
print(int('1000010010', base=2)) # str————>int二进制print('''
假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，
于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：
''')def int2(x,base=2):
return int(x, base)print(int2('100000000'))
print(int2('10101010'))print(int2('10101010',base=10))print('''
functools.partial就是帮助我们创建一个偏函数的，
不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：
''')import functoolsint2 = functools.partial(int,base=2)
print(int2('10010000'))max2 = functools.partial(max,10)
print(max2(5,6,7))
print(max2(5,66,7))

from builtins import map
from _functools import reduceprint(
'''
Python内建了map()和reduce()函数。
'''
)
print(
'''
我们先看map。map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：
'''
)def power(x, n = 2):
s = 1
while n > 0:
n = n - 1
s = s * x return sprint(list(map(power,[e for e in range(1,10)])))print(
'''
map()传入的第一个参数是f，即函数对象本身。
由于结果r是一个Iterator，Iterator是惰性序列，
因此通过list()函数让它把整个序列都计算出来并返回一个list。
'''
)print(list(map(str, range(1,11))))def add(x, y):
return x+y
print( reduce(add,[e for e in range(1,10) if e%2==1]) )def fn(x, y):
return x * 10 + y
print( reduce(fn,[e for e in range(1,10) if e%2==1]) )def chart2num(s):
return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10}[s]
print( reduce(fn,map(chart2num,'13579')) )print(
'''
整理成一个str2int的函数就是：
'''
)def str2int1(s):
def fn(x,y):
return x*10+y
def chart2num(s):
return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10}[s]
return reduce(fn,map(chart2num,s))
print( str2int1('13579') )print(
'''
还可以用lambda函数进一步简化成：
'''
)def str2int(s):
def fn(x,y):
return x+y
def chart2num(s):
return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10}[s]
return reduce(lambda x,y:x*10+y,map(chart2num,s))print( str2int('13579') )print('''
利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：
''')
def normalize(name):
return name[0].upper() + name[1:].lower()# 测试:
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)print('''
请编写一个prod()函数，可以接受一个list并利用reduce()求积：
''')
def prod(L):
return reduce(lambda x,y:x*y,L)print('3*5*7*9 = ',prod([3,5,7,9]))
print(3*5*7*9)print('''利用map和reduce编写一个str2float函数，
把字符串'123.456'转换成浮点数123.456：
''')def str2float(s):
l = list(map(int,s.split('.')))
print(l)
return reduce(lambda x,y:x+y*0.1**len(str(y)),l)print('str2float(\'123.456\') =', str2float('123.456'))

import timedef now():
return time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))print(now())f = now
print(f())print(now.__name__)print(f.__name__)print('''
现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，
这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。本质上，decorator就是一个返回函数的高阶函数。
所以，我们要定义一个能打印日志的decorator，可以定义如下：
''')def log(func):
def wrapper(*args, **kw):
print('call %s()' %func.__name__)
return func(*args,**kw)
return wrapper@log
def now():
return time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))print(now())print('''
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，
写出来会更复杂。比如，要自定义log的文本：
''')def log(msg):
def decorator(func):
def wrapper(*args, **kw):
print('%s %s()' %(msg, func.__name__))
return func(*args, **kw)
return wrapper
return decorator@log('execute')
def now():
return time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))print(now())
print(now.__name__)print('上面的写法有问题，为题就在于：函数名称改变了！为此Python语言给了解决方案，如下：')import functools
def log(msg):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('%s %s()' %(msg, func.__name__))
return func(*args, **kw)
return wrapper
return decorator@log('execute')
def now():
return time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))print(now())
print(now.__name__)

from builtins import filterprint('''
Python内建的filter()函数用于过滤序列。和map()类似，filter()也接收一个函数和一个序列。
和map()不同的是，
filter()把传入的函数依次作用于每个元素，
然后根据返回值是True还是False决定保留还是丢弃该元素。
''')print('在一个list中，删掉偶数，只保留奇数，可以这么写：')
def is_odd(n):
return n%2==1print(list(filter(is_odd, range(1, 20))))print('把一个序列中的空字符串删掉，可以这么写：')
def isEmpty(s):
return s and s.strip()print(list(filter(isEmpty, ['A','','','b',None,' ','c'])))print('用filter求素数:')
print('计算素数的一个方法是埃氏筛法，它的算法理解起来非常简单：')def oddIter():
n = 1
while 1:
n += 2
yield ndef isDivisible(n):
return lambda x:x%n>0def primes():
yield 2
it = oddIter() # 初始化序列
while 1:
n = next(it) # 返回序列第一个数
yield n
it = filter(isDivisible(n), it)# 打印1000以内的素数
for n in primes():
if (n < 1000):
print(n, end=" ")
else:
break