Python初识（一）

　　首先我有编程语言的基础，你也有就最好了，这样会很快认识Python。

　　当然由于本人见识和学识的局限性，请广大猿/媛们多多包涵与指正（希望多评论哦），共同进步嘛。

先看看python的学习路线图：

◆ 准备环境：到python官网下载python3.5；并安装(win安装教程：http://www.tuicool.com/articles/eiM3Er3/)。开发工具一般用pycharm或eclipse+pydev插件。

◆ 首先，python是比较懒的语言————语法相对精简，当然和scala没法比。

◆ 再次，Python的每个语句末尾没有标志结束符号（一般语言是封号————";"），全凭语言本身判断。

　　可是它有冒号":"和依赖缩进，用以代替以老括号“{}”，为标志的代码块。

　　当然这就决定了他对代码格式敏感，比如下面的格式是正确的：

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

◆ python的注释：

　　单行是井号　#，如：

　　#进入python世界的大门

　　print("Hello World！")

　　多行是 六个单引号，对你哦没看错，6个单引号！

　　'''

　　print("1111111111111111111")
　　print("2222222222222222222")
　　print("3333333333333333333")

　　'''

哦，对了。6个单引号还有个功能就是提供原样格式的字符串，如下：

 str = '''
 　　Hello, welcoming Python Word!
 wall,  please ask me question。
 start ..'''
 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：

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

 print(msg)    # 输出变量

eg2:

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

eg3:

 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!")

四、PY里的循环
python里只有while和for in
eg1:

 '''
 小游戏：—— 猜数字
     每个人都有一个幸运数字。
     猜对它，不管对与错，只有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.")

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　未完待续