Python初识（一）
首先我有编程语言的基础，你也有就最好了，这样会很快认识Python。
当然由于本人见识和学识的局限性，请广大猿/媛们多多包涵与指正（希望多评论哦），共同进步嘛。
先看看python的学习路线图：
◆ 准备环境：到python官网下载python3.5；并安装(win安装教程：http://www.tuicool.com/articles/eiM3Er3/)。开发工具一般用pycharm或eclipse+pydev插件。
◆ 首先，python是比较懒的语言————语法相对精简，当然和scala没法比。
◆ 再次，Python的每个语句末尾没有标志结束符号（一般语言是封号————";"），全凭语言本身判断。
可是它有冒号":"和依赖缩进，用以代替以老括号“{}”，为标志的代码块。
当然这就决定了他对代码格式敏感，比如下面的格式是正确的：
1 if inputNum > luky_num: 2 print("the real number is smaller...")
◆ python的注释：
单行是井号 #，如：
#进入python世界的大门
print("Hello World！")
多行是 六个单引号，对你哦没看错，6个单引号！
'''
print("1111111111111111111")
print("2222222222222222222")
print("3333333333333333333")
'''
哦，对了。6个单引号还有个功能就是提供原样格式的字符串，如下：
1 str = ''' 2 Hello, welcoming Python Word! 3 wall, please ask me question。 4 start ..''' 5 print(str)
一、声明变量
首先请看：
py 里的数据类型有如下几种：
数据类型
＊ 数字
Int
Float
Long
复数
＊ boolean 布尔
＊ str 字符串
＊ list 列表
＊ tuple 元组
＊ dict 字典
Python 声明变量无需关键字，类型也不用，语言本身会"类型推断"。
比如：
str1 = "我是什么类型？” #声明变量：语言本身会自己判断出这是字符串
NO = 5 #声明变量：语言本身会自己判断出这是int
li = ["I", "am", "python", "^|^"] #声明变量：语言本身会自己判断出这是列表（list）
dic = {'k1':'v1', "亚当":"夏娃"} #声明变量：语言本身会自己判断出这是字典（dict）
tu = (1,2,33, 55, 17101012345) #声明变量：语言本身会自己判断出这是元组(tuple)
二、python里的运算符大全
# ##################数字运算###############################
# % 取模 —— 返回除法的余数
# ** 幂——返回x的y次方
# / 取商——返回商
# // 取整除——返回商的整数部分
# == 等于——比较两个对象是否相等
# != 不等于——比较两个对象是否不相等
# = 等于——赋值
# > 大于
# < 小于
# <= 小于等于
# >= 大于等于
# += 加法赋值
# -= 减法赋值
# *= 乘法赋值
# /= 除法赋值
# %= 取模赋值
# **= 幂赋值
# ############位运算#######################################
# & 按位与运算
# | 按位或运算
# ^ 按位异或运算
# ~ 按位取反运算
# << 按位左移运算
# >> 按位右移运算
# >> 按位右移运算
# ############逻辑运算#######################################
# and 逻辑与
# or 逻辑或
# not 逻辑非
# ############成员运算#######################################
# in 运算符前边的元素在运算符后边的元素里吗？True:在;False:不在
# not in 运算符前边的元素不在在运算符后边的元素里吗？True:不在;False:在
# ############身份运算######################################
# #is 运算符前后是引用自同一对象吗？True:是的;False:不是
# not is 运算符前后不是引用自同一对象吗？True:不是;False:是的
# ############三目运算######################################
# res = 值1 if 条件 else 值2 # 若条件成立res=值1，否则res=值2
print(1 if 2 > 3 else 6)
三、py里的条件判断
eg1：
1 msg = "" # 变量定义 2 if (a > b) : # 条件判断 3 msg = 'a 大于 b' # 变量赋值 4 elif(a == b): # 条件判断 5 msg = 'a 和 b一样大' # 变量赋值 6 else: 7 msg = 'a 小于 b' # 变量赋值 8 9 print(msg) # 输出变量
eg2:
print(1 if 2 > 3 else 6) # 若条件成立输出1，否则输出6
eg3:
1 sex = input("您是man or girl？(请输入man or girl？)") 2 3 if sex is "girl": 4 print("I would like to have a limit monkey. ") 5 elif sex is "man": 6 print("I like MM.") 7 else: 8 print("Pervert! you are Pervert!")
四、PY里的循环
python里只有while和for in
eg1:
1 ''' 2 小游戏：—— 猜数字 3 每个人都有一个幸运数字。 4 猜对它，不管对与错，只有3次机会 5 ''' 6 7 luckyNum = 19 # 幸运数字 8 CI = 3 # 共有3此机会 9 curCi = 0 # 当前次数 10 11 while True: 12 inputNum = int(input("请输入您的幸运数字（共有" + CI + "次机会，还有" + str(CI-curCi) + "次机会哦^_^）：")) 13 curCi += 1 14 if luckyNum == inputNum: 15 print("bingo！结束") 16 break 17 elif luckyNum > inputNum: 18 print("The number is big, this number is smaller.") 19 else: 20 print("The number is small,this number is bigger.")
eg2:
# 求素数
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)
# 循环结构中else子句判断循环有没有提前退出：若提前退出了则不执行else；若如果没有提前退出则执行else；
五、py内置数据结构
首先看看：
1）列表——list——用[ ]符号表示
例如：[1,2,3,4]
2）元组——tuple——用( )符号表示
例如：（'d',300）
3）字典——dict——用{ }符号表示
例如：｛'name':'coco','country':'china'｝
python可变数据类型：列表list[ ]、字典dict{ }
python不可变数据类型：整型int、字符串str' '、元组tuple（）
六、函数(python的函数大有学问，主要是糅合了函数式编程的思想。让我们慢慢学习它的强大吧)
eg1：带默认值的参数
print('''
计算 X^n 的值
''')
def power(x, n = 2): # 参数有默认值
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print(power(2))
print(power(2,2))
print(power(2,3))
print(power(2,4))
print(power(2,5))
eg2：可变参数
print(
'''
给定一组数字a，b，c……，请计算a^2 + b^2 + c^2 + ……
'''
)
def calc(*number): # 可变参数(任意参数)
sum = 0
for n in number:
sum += n * n
return sum
print(calc(*[1,2,3]))
print(calc(*(1,2,3)))
print(calc(1,2,3))
eg3:lambda和匿名函数
# 利用lambda来充当匿名函数
# lambda 格式:封号之前是参数列表，封号之后是函数体
print('求X^^2:',list(map(lambda x:x*x,range(1,10))))
f = lambda x:x*x
print(f(5))
eg4:高阶函数
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('把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。')
eg5:返回值是函数————闭包
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 fs
f1,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 fs
f21,f22,f23 = count2()
print('f21() = %s, f22() = %s, f23() = %s' %(f21(), f22(), f23()))
eg6:偏函数
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 functools
int2 = functools.partial(int,base=2)
print(int2('10010000'))
max2 = functools.partial(max,10)
print(max2(5,6,7))
print(max2(5,66,7))
eg7：map()、reduce()
from builtins import map
from _functools import reduce
print(
'''
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 s
print(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'))
eg8:装饰器
import time
def 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__)
eg9:filter()
from builtins import filter
print('''
Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。
和map()不同的是，
filter()把传入的函数依次作用于每个元素，
然后根据返回值是True还是False决定保留还是丢弃该元素。
''')
print('在一个list中，删掉偶数，只保留奇数，可以这么写：')
def is_odd(n):
return n%2==1
print(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 n
def isDivisible(n):
return lambda x:x%n>0
def 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
七、py里的正则
import re
m = re.match('abc', 'abcqwerab') # 匹配字符串
if m:print(m.group())
m = re.match('[0-9]', 'abc1qwe2rab') # 匹配0~9的一个数字
if m:print(m.group())
m = re.match('[0-9]', '6abcqwerab') # 匹配0~9的一个数字
if m:print(m.group())
m = re.match('[0-9]{11}', '13910116688') # 匹配11次0~9的数字
if m:print(m.group())
m = re.match('[0-9]{0,10}', '6abcqwerab') # 匹配【0~10】次0~9的一个数字
if m:print(m.group())
m = re.findall('[0-9]{11}', '6abcqwerab13901016688') # 匹配11次0~9的数字
if m:print(m)
m = re.findall('[0-9]{0,11}', '6abcqwerab13901016688') # 匹配【0~11】次0~9的数字
if m:print(m)
m = re.findall('[0-9]{1,11}', '6abcqwerab13901016688') # 匹配【1~11】次0~9的数字
if m:print(m)
m = re.findall('[a-zA-Z]{1,11}', '6abcqre3werab13901016688') # 匹配【1~11】次a~z/A~Z的字母
if m:print(m)
m = re.findall('.*', '6abcqre3werab13901016688') # 匹配0个或多个所有的（包括空串‘’）
if m:print(m)
m = re.findall('.+', '6abcqr?e#3w!erab13901016688') # 匹配0个或多个所有的（不包括空串‘’）
if m:print(m)
m = re.findall('[a-zA-z]+', '6abcqr?e#3w!er！@#￥%……&*（）a_+b13901016688') # 匹配0个或多个所有字符（不包括空串‘’）
if m:print(m)
m = re.findall('~', '6abcqr?e#3!~w!er！@#￥%……&*（）a_+b13901016688') # 匹配0个或多个所有的'~'（不包括空串‘’）
if m:print(m)
m = re.search('\d+', '66.886abcqwerab') # 匹配多次0~9的一个数字
if m:print(m.group())
m = re.search('\d+', 'def66.886abcqwerab') # 匹配多次0~9的一个数字
if m:print(m.group())
m = re.search('^\d+', 'def66.886abcqwerab') # 匹配以【多次0~9的一个数字】开头
if m:print(m.group())
m = re.search('^\d+', '22def66.886abcqwerab') # 匹配以【多次0~9的一个数字】开头
if m:print(m.group())
m = re.search('^\d+$', '22def66.886abcqwerab') # 匹配以【多次0~9的一个数字】开头且以【多次0~9的一个数字】结尾
if m:print(m.group())
m = re.search('^\d+$', '13901016688') # 匹配以【多次0~9的一个数字】开头且以【多次0~9的一个数字】结尾
if m:print(m.group())
m = re.sub('\d+', '|', 'def66.886abcqwerab') # 匹配多次0~9的一个数字并替换成‘|’
print(m)
m = re.sub('\d+', '|', 'def66.886abcqwerab', count=2) # 匹配2次0~9的一个数字并替换成‘|’
print(m)
附几个学习Python不错的教程吧：
http://www.cnblogs.com/vamei/archive/2012/09/13/2682778.html
http://www.runoob.com/python/python-tutorial.html
未完待续
