Python基础
# 输入和输出
# 输出:print()
说明:使用print(字符串)函数来打印输出
#打印单个字符串
>>>print('hello, world')
#打印多个字符串,中间用,号分开
>>>print('hello', 'world')
('hello', 'world')
#打印整数
>>> print(100+200)
300
>>> print('100 + 200 =', 100 + 200)
('100 + 200 =', 300)
2
3
4
5
6
7
8
9
10
# 输入:raw_input()和input()
说明:
- 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
- raw_input() 将所有输入作为字符串看待,返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性,它返回所输入的数字的类型( int, float );同时在例子 1 知道,input() 可接受合法的 python 表达式,举例:input( 1 + 3 ) 会返回 int 型的 从help(input)的帮助结果可知,input()本质上还是通过raw_input()实现的,只是调用完 raw_input() 之后再调用 eval() 函数,所以,你甚至可以将表达式作为 input() 的参数,并且它会计算表达式的值并返回它。 除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
>>> name = input("you name:")
you name:fangzheng
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
NameError: name 'fangzheng' is not defined
>>> name = raw_input("you name:")
you name:fangzheng
>>> print name
fangzheng
>>>
2
3
4
5
6
7
8
9
10
11
# 数据类型
# 整数
python可以处理任意大小的整数,包括负整数
# 浮点数
浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时, 一个浮点数的小数点位置是可变的。 Python 的浮点数也没有大小限制,但是超出一定范围就直接表示为 inf (无限大)。
# 字符串
字符串是以单引号'或双引号"括起来的任意文本,如果字符串中有'或者“时,可以使用转义字符\
>>> print("I'm ok")
I'm ok
#使用\转义
>>> print('I\'m \"OK\"!')
I'm "OK"!
#使用r标识,表示''内部的字符串默认不转义
>>> print(r'\\\t\\')
\\\t\\
2
3
4
5
6
7
8
# 布尔
python中的布尔值是True和Flase,都是大写。注意:Python是区分大小写的
# 空值
空值是 Python 里一个特殊的值,用 None 表示。None 不能理解为 0,因 为 0 是有意义的,而 None 是一个特殊的空值。
# 数据结构
Python中有4种数据接口,分别是列表、字典、元组、集合
list = [val1,val2,val3,val4]
dict = {key1:val1,key2:val2}
tuple = (val1,val2,val3,val4)
set = {val1,val2,val3,val4}
2
3
4
# list:列表
列表中的每一个元素都是可变的
列表中的元素是有序的,每一个元素都是有位置的
列表可以容纳Python中的任何对象
例如:下面的list
all_in_list = [ 1, # 整数 1.0, # 浮点数 'a word', # 字符串 print(1), # 函数 True, # 布尔值 [1,2], # 列表中套列表 (1,2), # 元组 {'key':'value'} # 字典 ]
1
2
3
4
5
6
7
8
9
10
Python 内置的一种数据类型是列表:list。list 是一种有序的集合,可以 随时添加和删除其中的元素。 比如,列出班里所有同学的名字,就可以用一个 list 表示:
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
#获取最后一个元素:
>>> classmates[-1]
'Tracy'
#往 list 中追加元素到末尾
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
#也可以把元素插入到指定的位置,比如索引号为 1 的位置:
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
#要删除 list 末尾的元素,用 pop()方法:
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
#要删除指定位置的元素,用 pop(i)方法,其中 i 是索引位置:
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
#要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
#list 里面的元素的数据类型也可以不同,比如:
>>> L = ['Apple', 123, True]
#list 元素也可以是另一个 list,比如:
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# tuple:元组
有序列表叫元组:tuple。tuple 和 list 非常类似,但是 tuple 一旦 初始化就不能修改,比如同样是列出同学的名字:
>>> classmates = ('Michael', 'Bob', 'Tracy')
#现在,classmates 这个 tuple 不能变了,它也没有 append(),insert()这样 的方法。其他获取元素的方法和 list 是一样的,你可以正常地使用 classmates[0],classmates[-1],但不能赋值成另外的元素。
#当你定义一个 tuple 时,在定义的时候,tuple 的元素就必须被确定下来,比如:
>>> t = (1, 2)
>>> t
(1, 2)
2
3
4
5
6
# dict:字典
Python 内置了字典:dict 的支持,dict 全称 dictionary,在其他语言中也 称为 map,使用键-值(key-value)存储,key 必须是不可 变对象。具有极快的查找速度。 用 Python 写一个 dict 如下:
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
#要避免 key 不存在的错误,有两种办法,一是通过 in 判断 key 是否存在:
>>> 'Thomas' in d
False
#通过 dict 提供的 get 方法,如果 key 不存在,可以返回 None,或者 自己指定的 value:
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
#注意,dict 内部存放的顺序和 key 放入的顺序是没有关系的。
2
3
4
5
6
7
8
9
10
11
和 list 比较,dict 有以下几个特点:
- 查找和插入的速度极快,不会随着key的增加而增加;
- 需要占用大量的内存,内存浪费多。 而 list 相反:
- 查找和插入的时间随着元素的增加而增加;
- 占用空间小,浪费内存很少。
# set:集合
set 和 dict 类似,也是一组 key 的集合,但不存储 value。由于 key 不能 重复,所以,在 set 中,没有重复的 key。
#要创建一个 set,需要提供一个 list 作为输入集合:
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意,传入的参数[1, 2, 3]是一个 list,而显示的{1, 2, 3}只是告诉你
这个 set 内部有 1,2,3 这 3 个元素,显示的顺序也不表示 set 是有序的。
#重复元素在 set 中自动被过滤:
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
#重复元素在 set 中自动被过滤:
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
#通过 remove(key)方法可以删除元素:
>>> s.remove(4)
>>> s
{1, 2, 3}
#set 可以看成数学意义上的无序和无重复元素的集合,因此,两个 set 可 以做数学意义上的交集、并集等操作:
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 其他语法
# 除法
python中有两种除法 1.直接使用/除法:表示除的结果取精确结果
>>> 10 / 3
3.3333333333333335
2
2.使用//除法(地板除):表示除的结果取整
>>> 10 // 3
3
2
# 字符串和编码
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'
2
3
4
5
6
7
8
# 字符串格式化
如果你不太确定应该用什么,%s 永远起作用,它会把任何数据类型转换 为字符串: 常见占位符: %d 整数 %f 浮点数 %s 字符串 %x 十六进制整数
>>> 'Hello, %s' % 'world'
'Hello, world'
2
# 字符串格式化之format
>>> word = 'word!!!'
>>> 'Hello, {word}'.format(word=word)
'Hello, word!!!'
2
3
# python内置的数据类型转换
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False
2
3
4
5
6
7
8
9
10
11
12
13
14
# 函数
函数如果没有 return 语句,函数执行完毕后也会返回结果,只是结果为 None。
# 定义函数
def 函数名(参数): 函数体 例如:求绝对值的 my_abs 函数
def my_abs(x):
if x >= 0:
return x
else:
return -x
2
3
4
5
# 空函数
空的函数,什么都不做。函数体里使用pass关键字就行
def nop():
pass
2
# 函数返回多个值
Python 的函数返回多值其实就是返回一个 tuple
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
#以上move函数的返回值是一个tuple
2
3
4
5
# 函数中参数的默认参数
def power(x, n=2):
s =1
while n > 0:
n=n- 1
s=s* x
return s
#这样,当我们调用 power(5)时,相当于调用 power(5, 2):
>>> power(5)
25
>>> power(5, 2)
25
#而对于 n > 2 的其他情况,就必须明确地传入 n,比如 power(5, 3)
2
3
4
5
6
7
8
9
10
11
12
# 函数的可变参数
可变参数使用*号来定义
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
2
3
4
5
# 高阶函数
# Map
map 函数的使用形式如下:
map(function, Iterable)
- 参数1:function
- 参数2:序列
解释:对 Iterable 中的 item 依次执行 function(item)
,并将结果组成一个 List 返回,也就是:
[function(item1), function(item2), function(item3), ...]
举例说明,比如我们有一个计算一个数字平方值的函数f(x)=x2,要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]
上,就可以用map()实现如下:
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
2
3
4
5
6
其他例子:
>>> def square(x):
... return x * x
>>> map(square, [1, 2, 3, 4])
[1, 4, 9, 16]
>>> map(lambda x: x * x, [1, 2, 3, 4]) # 使用 lambda
[1, 4, 9, 16]
# 将数字转为字符串
>>> map(str, [1, 2, 3, 4])
['1', '2', '3', '4']
# 将字符串转为数字
>>> map(int, ['1', '2', '3', '4'])
[1, 2, 3, 4]
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Reduce
reduce把一个函数作用在一个序列[x1, x2, x3, ...]
上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
比方说对一个序列求和,就可以用reduce实现:(当然求和运算可以用sum()
函数)
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
2
3
4
5
6
# filter
filter 函数用于过滤元素,它的使用形式如下:
filter(function, sequnce)
- 参数1:function
- 参数2:序列
和map()类似,filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
例子1:在一个list中,删掉偶数,只保留奇数,可以这么写:
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]
2
3
4
5
例子2:把一个序列中的空字符串删掉,可以这么写:
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 结果: ['A', 'B', 'C']
2
3
4
5
警告
注意: filter()函数返回的是一个Iterator,也就是一个惰性序列,所以要强迫filter()完成计算结果,需要用list()函数获得所有结果并返回list。
# sorted
Python内置的sorted()函数就可以对list进行排序:
例子1:对数字排序
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
2
此外,sorted()函数也是一个高阶函数,它还可以接收一个key函数来实现自定义的排序,例如按绝对值大小排序:
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
2
例子2:字符串排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
2
警告
默认情况下,对字符串排序,是按照ASCII的大小比较的,由于'Z' < 'a',结果,大写字母Z会排在小写字母a的前面。
这样,我们给sorted传入key函数,即可实现忽略大小写的排序:
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
2
# 返回函数
返回函数比较简单,也就是一个函数的返回值是一个函数。所以,Python中,既可以将函数当做参数,也可以把函数作为结果返回。
例子:求和的函数
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
2
3
4
5
6
7
当我们调用lazy_sum()时,返回的并不是求和结果,而是求和函数:
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
# 调用函数f时,才真正计算求和的结果:
>>> f()
25
2
3
4
5
6
7
# 匿名函数
在 Python 中,我们使用 def 语句来定义函数,比如:
def double(x):
return 2 * x
2
除了用上面的方式定义函数,Python 还提供了一个关键字 lambda,让我们可以创建一个匿名函数,也就是没有名称的函数。它的形式如下:
lambda 参数: 表达式
关键字 lambda 说明它是一个匿名函数 冒号 : 前面的变量是该匿名函数的参数,冒号后面是函数的返回值,注意这里不需使用 return 关键字。
我们将上面的 double 函数改写成一个匿名函数,如下:
lambda x: 2 * x
那怎么调用匿名函数呢?可以直接这样使用:
>>> (lambda x: 2 * x)(8)
16
2
由于匿名函数本质上是一个函数对象,也可以将其赋值给另一个变量,再由该变量来调用函数,如下:
>>> f = lambda x: 2 * x # 将匿名函数赋给变量 f
>>> f
<function <lambda> at 0x7f835a696578>
>>> f(8)
16
2
3
4
5
# 偏函数
# 高级特性
# 切片Slice
切片表示将一个数据结构切片取部分内容。
例如: 以下一个list,取其中前3个元素。可使用切片的方式[开始索引:结束索引]
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[0:3] # 取前3个元素
['Michael', 'Sarah', 'Tracy']
>>> L[:3] # 如果第一个索引是0,还可以省略
['Michael', 'Sarah', 'Tracy']
# Python支持L[-1]取倒数第一个元素:记住倒数第一个元素的索引是-1。
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']
2
3
4
5
6
7
8
9
10
11
12
13
# 迭代
在Python中,迭代是通过for ... in来完成的。也就是说,在Python中可以使用通用的for ... in的方式来迭代(list,tupe,map等)。如果是map,默认情况下迭代的是key
如果要迭代value,可以用for value in d.values(),如果要同时迭代key和value,可以用for k, v in d.items()。
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>>
>>>
>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> for key in d: # 默认遍历的是key
... print(key)
...
a
b
c
# Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身:
>>> for i, value in enumerate(['A', 'B', 'C']):
... print(i, value)
...
0 A
1 B
2 C
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
所以,只要是一个可迭代的对象,都是可以使用for ... in 的方式来迭代。但是,如何判断一个对象是一个可迭代对象呢?
提示
通过collections模块的Iterable类型来判断一个对象是否是可迭代对象
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
2
3
4
5
6
7