输入和输出

输出:print()

说明:使用print(字符串)函数来打印输出

#打印单个字符串
>>>print('hello, world')
#打印多个字符串,中间用,号分开
>>>print('hello', 'world')
('hello', 'world')
#打印整数
>>> print(100+200)
300
>>> print('100 + 200 =', 100 + 200)
('100 + 200 =', 300)
1
2
3
4
5
6
7
8
9
10

输入:raw_input()和input()

说明:

  1. 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
  2. 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
>>>
1
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\\
1
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}
1
2
3
4

list:列表

  1. 列表中的每一个元素都是可变的

  2. 列表中的元素是有序的,每一个元素都是有位置的

  3. 列表可以容纳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']
1
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)
1
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 放入的顺序是没有关系的。
1
2
3
4
5
6
7
8
9
10
11

和 list 比较,dict 有以下几个特点:

  1. 查找和插入的速度极快,不会随着key的增加而增加;
  2. 需要占用大量的内存,内存浪费多。 而 list 相反:
  3. 查找和插入的时间随着元素的增加而增加;
  4. 占用空间小,浪费内存很少。

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 内部有 1233 个元素,显示的顺序也不表示 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}
1
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
1
2

2.使用//除法(地板除):表示除的结果取整

>>> 10 // 3 
3
1
2

字符串和编码

>>> ord('A') 
65
>>> ord('中') 
20013
>>> chr(66) 
'B'
>>> chr(25991) 
'文'
1
2
3
4
5
6
7
8

字符串格式化

如果你不太确定应该用什么,%s 永远起作用,它会把任何数据类型转换 为字符串: 常见占位符: %d 整数 %f 浮点数 %s 字符串 %x 十六进制整数

>>> 'Hello, %s' % 'world'
'Hello, world'
1
2

字符串格式化之format

>>> word = 'word!!!'
>>> 'Hello, {word}'.format(word=word)
'Hello, word!!!'
1
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
1
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
1
2
3
4
5

空函数

空的函数,什么都不做。函数体里使用pass关键字就行

def nop():
    pass
1
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
1
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)
1
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
1
2
3
4
5

高阶函数

Map

map 函数的使用形式如下:

map(function, Iterable)

  • 参数1:function
  • 参数2:序列

解释:对 Iterable 中的 item 依次执行 function(item),并将结果组成一个 List 返回,也就是:

[function(item1), function(item2), function(item3), ...]
1

举例说明,比如我们有一个计算一个数字平方值的函数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]
1
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]
1
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
1
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]
1
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']
1
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]
1
2

此外,sorted()函数也是一个高阶函数,它还可以接收一个key函数来实现自定义的排序,例如按绝对值大小排序:

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
1
2

例子2:字符串排序

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
1
2

默认情况下,对字符串排序,是按照ASCII的大小比较的,由于'Z' < 'a',结果,大写字母Z会排在小写字母a的前面。

这样,我们给sorted传入key函数,即可实现忽略大小写的排序:

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
1
2

返回函数

返回函数比较简单,也就是一个函数的返回值是一个函数。所以,Python中,既可以将函数当做参数,也可以把函数作为结果返回。

例子:求和的函数

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
1
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
1
2
3
4
5
6
7

匿名函数

在 Python 中,我们使用 def 语句来定义函数,比如:

def double(x):
    return 2 * x
1
2

除了用上面的方式定义函数,Python 还提供了一个关键字 lambda,让我们可以创建一个匿名函数,也就是没有名称的函数。它的形式如下:

lambda 参数: 表达式
1

关键字 lambda 说明它是一个匿名函数 冒号 : 前面的变量是该匿名函数的参数,冒号后面是函数的返回值,注意这里不需使用 return 关键字。

我们将上面的 double 函数改写成一个匿名函数,如下:

lambda x: 2 * x
1

那怎么调用匿名函数呢?可以直接这样使用:

>>> (lambda x: 2 * x)(8)
16
1
2

由于匿名函数本质上是一个函数对象,也可以将其赋值给另一个变量,再由该变量来调用函数,如下:

>>> f = lambda x: 2 * x   # 将匿名函数赋给变量 f  
>>> f
<function <lambda> at 0x7f835a696578>
>>> f(8)
16
1
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']
1
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
1
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
1
2
3
4
5
6
7

列表生成式

廖雪峰-列表生成式

生成器

迭代器


1000000+