首先我有编程语言的基础，你也有就最好了，这样会很快认识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 ineg1:

1 '''

2 小游戏：—— 猜数字3 每个人都有一个幸运数字。4 猜对它，不管对与错，只有3次机会5 '''

6

7 luckyNum = 19 #幸运数字

8 CI = 3 #共有3此机会

9 curCi = 0 #当前次数

10

11 whileTrue: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不错的教程吧：

未完待续