1.数据类型和变量
# coding=utf-8
"""
数据类型:整数、浮点数、字符串、布尔值(True,False)、空值
变量(大小写英文、数字和_的组合，且不能用数字开头)
常量(不能变d变量，字母全部大写)
"""
a = 10 # a是整数
b = 1.11 # b是浮点数
c = "I\'m \"OK\"!\n" # c和d是字符串
d = 'I\'m learning\tPython.\n'
e = True # e为布尔型
f = None # f为空值
print(a, b, c, d, e, f)
s = a
a = 11
print(a, s)
PI = 301415926
# 精确除
print(10 / 3)
# 取整
print(10 // 3)
# 取余
print(10 % 3)
Snip20170913_2.png
2.字符串和编码
"""
字符编码：ASCII编码、Unicode、UTF-8
ASCII编码：占用一个字节，表示大小写英文字母、数字和一些符号
Unicode编码：通常占用两个字节，把所有语言都统一到一套编码里
UTF-8：可变长编码，节省空间，常用的英文字母被编码成1个字节，汉字通常是3个字节
格式化字符串：%d(整数)、%f(浮点数)、%s(字符串)、%x(十六进制整数)
"""
# 获取字符的整数表示:
print(ord('A'))
print(ord('中'))
# 把编码转换为对应的字符：
print(chr(65))
print(chr(25444))
# str变为bytes 用encode()方法
print('中文'.encode('utf-8'))
print('abc'.encode('ascii'))
# bytes变为str 用decode()方法
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))
print(b'abc'.decode('ascii'))
# 计算str有几个字符 用len()
print(len('acvv'))
print(len('哈哈好啊好啊'))
# 格式化字符串
print('%d-%.2f' % (4, 44.321))
print('age: %d. gender: %s' % (11, "hh"))
Snip20170913_3.png
3.list和tuple
"""
list和tuple
共同点：有序集合，元素的数据类型可以不同
不同点：
list:可随时添加和删除其中的元素
tuple：一旦初始化就不能修改
"""
# list
classmates = ['michael', 'bob', 'tracy']
# 获取list元素个数
print(len(classmates))
# 用索引来访问list元素
print(classmates[0])
print(classmates[2])
print(classmates[-1]) # 倒数第一个
print(classmates[-2]) # 倒数第二个
# 追加元素到末尾
classmates.append('adam')
print(classmates)
# 插入到指定位置
classmates.insert(2, 'jack')
print(classmates)
# 删除list末尾的元素
classmates.pop()
print(classmates)
# 删除指定位置元素
classmates.pop(1)
print(classmates)
# 根据索引修改元素
classmates[1] = 'sarah'
print(classmates)
# tuple
cla = ('mm', 'ss', 'cc')
print(cla[2])
Snip20170913_4.png
4.条件判断
"""
条件判断
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
"""
age = 3
if age >= 18:
print('adult')
elif age >= 6:
print('teenager')
else:
print('kid')
5.循环
"""
循环
1.for...in
2.while
break和continue
"""
names = ['mm', 'ss', 'cc']
for name in names:
print(name)
s = 0
for x in range(10):
s = s + x
print(s)
sm = 0
n = 10
while n > 0:
sm = sm + n
n = n - 1
print(sm)
# break:退出当前循环
n = 1
while n <= 20:
if n > 5:
break
print(n)
n = n + 1
print('END')
# continue:跳出当前的这一次循环，继续开始下一次循环
n = 0
while n < 10:
n = n + 1
if n % 2 == 0:
continue
print(n)
Snip20170913_5.png
6.dict和set
"""
dict:使用key-value存储
set:一组key的集合，无重复元素
"""
# dict
d = {'mm': 55, 'ss': 44, 'll': 33}
print(d)
# 取出某个key对应的value
print(d['mm'])
print(d.get('mm'))
# 添加
d['aa'] = 99
print(d)
# 修改某个key对应的value
d['aa'] = 88
print(d)
# 删除一个key
d.pop('aa')
print(d)
# set
s = set([1, 2, 3])
print(s)
s = set([1, 2, 2, 4, 4])
print(s)
# 添加
s.add(3)
print(s)
s.add(4)
print(s)
# 删除
s.remove(4)
print(s)
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2) # 交集
print(s1 | s2) # 并集
Snip20170913_6.png
7.函数
"""
函数
定义函数：def 函数名(参数): return语句
函数的参数：
1.位置参数
2.默认参数
3.可变参数：允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
4.关键字参数：关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
5.命名关键字参数:要限制关键字参数的名字,命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
"""
import math
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
print('--------------------')
print(my_abs(-4))
def move(x, y, step, angle=0): # angle是默认参数
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny # 返回多个值
print('--------------------')
print(move(1, 2, 2))
print('--------------------')
print(move(1, 2, 2, 1)) # 默认参数此时的值为1
# 可变参数
def calc(*numbers):
sm = 0
for n in numbers:
sm = sm + n * n
return sm
print('--------------------')
print(calc(1, 2, 3,))
nums = [1, 2, 3]
print('--------------------')
print(calc(*nums)) # *nums把nums这个list的所有元素作为可变参数传进去
# 关键字参数
def person(name, age, **kw):
print("name:", name, "age:", age)
for k in kw:
print(k, kw[k])
print('--------------------')
person('Adam', 45, gender='M', job='Engineer')
extra = {'city': 'Beijing', 'job': 'Engineer'}
print('--------------------')
person('Jack', 24, **extra) # **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数
# 命名关键字参数
def person(name, age, *, city, job):
print(name, age, city, job)
print('--------------------')
person('Jack', 24, city='Beijing', job='Engineer')
# 组合参数
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
print('--------------------')
f1(1, 2, 3, 'a', 'b', x=99)
"""
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict
"""
Snip20170914_7.png
8.切片
"""
切片
"""
L = list(range(100)) # 创建一个0-99的数列
print(L[:10]) # 取前10个
print(L[-10:]) # 取后10个
print(L[10:20]) # 取前11-20个数
print(L[:10:2]) # 取前10个,每两个取一个
print(L[::5]) # 所有数，每5个取一个
Snip20170914_8.png
9.迭代
"""
迭代：for...in 遍历list或tuple或dict
"""
d = {'a': 1, 'b': 2, 'c': 3}
# 迭代key
for key in d:
print(key)
print('-----------------')
# 迭代value
for value in d.values():
print(value)
print('-----------------')
# 同时迭代key和value
for k, v in d.items():
print(k, v)
print('-----------------')
# 如何判断一个对象是可迭代对象呢？
from collections import Iterable
print(isinstance('abc', Iterable)) # str是否可迭代
print(isinstance([1, 2, 3], Iterable)) # list是否可迭代
print(isinstance(123, Iterable)) # 整数是否可迭代
print('-----------------')
# enumerate函数可以把一个list变成索引-元素对
for i, value in enumerate(['A', 'B', 'C']):
print(i, value)
print('-----------------')
# 同时引用两个变量
for x, y in [(1, 1), (2, 4), (3, 9)]:
print(x, y)
Snip20170914_9.png
10.列表生成式
"""
列表生成式(List Comprehensions)
"""
print(list(range(1, 11)))
print([x * x for x in range(1, 11)])
print([x * x for x in range(1, 11) if x % 2 == 0])
print([m + n for m in 'ABC' for n in 'XYZ'])
d = {'x': 'A', 'y': 'B', 'z': 'c'}
print([k + '=' + v for k, v in d.items()])
L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])
Snip20170914_10.png
11.生成器
"""
生成器(generator)
"""
g = (x * x for x in range(10))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print('----------')
l = (x * x for x in range(10))
for n in l:
print(n)
print('----------')
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'
print(fib(6))
print('----------')
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
b = fib(6)
print(b) # b是一个generator
print('----------')
for n in fib(6):
print(n)
Snip20170914_12.png
12.迭代器
"""
迭代器(Iterator)：可以被next()函数调用并不断返回下一个值的对象。它们表示一个惰性计算的序列
可以直接作用于for循环的对象统称为可迭代对象：Iterable.包括：list、tuple、dict、set、str、generator
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象
Python的for循环本质上就是通过不断调用next()函数实现的
"""
from collections import Iterable
from collections import Iterator
print(isinstance([], Iterable))
print(isinstance([], Iterator))
print('-------------')
print(isinstance({}, Iterable))
print(isinstance({}, Iterator))
print('-------------')
print(isinstance((x for x in range(10)), Iterable))
print(isinstance((x for x in range(10)), Iterator)) # 生成器都是Iterator对象
print('-------------')
# 把list、dict、str等Iterable变成Iterator可以使用iter()函数：
print(isinstance(iter([]), Iterable))
print(isinstance(iter([]), Iterator))
Snip20170914_11.png
13.高阶函数
from functools import reduce
"""
高阶函数
map():map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回.
reduce():reduce把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做计算
filter():用于过滤序列,把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
sorted():排序，可以接收一个key函数来实现自定义的排序
"""
# map()
def f(x):
return x * x
r = map(f, [1, 2, 3, 4, 5, 6])
print(list(r)) # 结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
# 把list所有数字转为字符串
print(list(map(str, [1, 2, 3, 4, 5, 6])))
# reduce()
def add(x, y):
return x + y
print(reduce(add, [1, 2, 3, 4, 5]))
def fn(x, y):
return x * 10 + y
print(reduce(fn, [1, 3, 5, 7, 9]))
# map()和redce()组合使用
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
print(reduce(lambda x, y: x * 10 + y, map(char2num, '13579')))
print('----------------')
# filter()返回的是一个Iterator，也就是一个惰性序列,用list()函数获得所有结果并返回list
# 删掉空字符串
def not_empty(s):
return s and s.strip()
print(list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])))
# sorted()
print('----------------')
print(sorted([36, 5, -12, 9, -21]))
print(sorted([36, 5, -12, 9, -21], key=abs)) # 按绝对值大小排序
print(sorted(['bob', 'about', 'Zoo', 'Credit']))
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)) # 按小写排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)) # 反向排序
Snip20170915_13.png
14.返回函数和匿名函数
"""
返回函数
匿名函数:关键字lambda表示匿名函数，冒号前面的x表示函数参数。匿名函数只能有一个表达式，不用写return，返回值就是该表达式的结果。
"""
# 返回函数
def lazy_sum(*args):
def sm():
ax = 0
for n in args:
ax = ax + n
return ax
return sm
f = lazy_sum(1, 3, 5, 7, 9)
print(f()) # 调用函数f
# 匿名函数
ax = lambda x: x * x
print(ax(5))
def build(x, y):
return lambda: x * x + y * y # 把匿名函数作为返回值返回
print(build(2, 3)())
Snip20170915_14.png
15.装饰器
"""
装饰器：在代码运行期间动态增加功能，decorator就是一个返回函数的高阶函数，
"""
def log(func):
def wrapper(*args, **kw):
print('call %s()' % func.__name__)
return func(*args, **kw)
return wrapper
@log
def now():
print('2017-07-07')
now()
Snip20170915_16.png