3.python知识总结_pretty printing has been turned off

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TJ2Nu8iD-1600071235214)(…/img/chinahadoop.png)]

Python编程

Python介绍

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v9UCleYI-1600071235218)(…/img/python.png)]
Python 是一种简单易学，功能强大的编程语言，它有高效率的高层数据结构，简单而有效地实现面向对象编程。Python 简洁的语法和对动态输入的支持，再加上解释性语言的本质，使得它在大多数平台上的许多领域都是一个理想的脚本语言，特别适用于快速的应用程序开发。

Python与Java, C, C++并列为全球4大最流行语言. 从C到C++,到Java再到Python, 细节越来越少, 让开发者把更多的精力放在”做什么”, 而不是”怎么做”。

更多python语言介绍和入门可以参考资料《Python简介和入门》

%config ZMQInteractiveShell.ast_node_interactivity='all'
%pprint
1

Pretty printing has been turned OFF
1

Python的两种运行方式

解释运行

• 新建py文件，直接运行

%%writefile print_str.py
print("欢迎大家学习课程内容！")
1

Overwriting print_str.py
1

!python3 print_str.py

欢迎大家学习课程内容！
1

交互运行

• ipython, notebook

Python标识符

合法标识符

• 数字，下划线，字母构成
• 避开关键字
• 不能用数字开头

如以下标识符取名错误
for='chinahadoop.cn'
7a=8
str='小象学院'
1
2
3
4

好的命名习惯让开发更有效率

• 变量，函数或方法:salary,houseworker,booksname
• 常量：INTEREST_RATES
• 类：BankAccount,Employee,Company,OrderedDict #骆峰命名法

名字与对象之间的建立引用与解除引用

我们可以使用=建立名字与对象之间的关联，用del 名字来解除这种关联

标准操作符及优先级

操作符及优先级如下：

第1名 - 函数调用、寻址、下标
第2名 - 幂运算 **
第3名 - 翻转运算符 ~
第4名 - 正负号
第5名 - *、/、%
第6名 - +、-
1
2
3
4
5
6

#算术运算符
a=100;b=3
a+b #加
a-b #减
a*b #乘
a/b #除
a//b #取商
a%b #取余
a**2 #平方
a**0.5 #开方
1
2
3
4
5
6
7
8
9

103






97






300






33.333333333333336






33






1






10000






10.0
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#比较运算符  
if a==b:
    print ('a equal b')

if a!=b:
    print ('a not equal b')
    
#逻辑运算符><>=,
if a>=50:
    print('a is grater than 50')
    
#成员运算符in,not in
websiteUrl='chinahadoop.cn'
if '.net' not in websiteUrl:
    print ('.net not in it')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

a not equal b
a is grater than 50
.net not in it
1
2
3

#赋值
c = 1000

#多重赋值
#a=100;b=100
a=b=100

#多元赋值
#a=100;b=200
a,b,c=100,200,200

#交换赋值
a,b=b,a
print(a,b)
1
2
3
4
5
6
7
8
9
10
11
12
13

200 100
1

# 拓展知识

#unpack解包
l1=[1,2,3,4,5,'6']
a,b,*c,d=l1
print(a,b,c,d)

#*号收集
a,*b,c=l1
print(a,b,c)

#*号展开,针对序列
l1=[1,2,3,4]
s1='chinahadoop.cn'
[*l1,*s1]

#*号展开,针对字典
d1={'name':'machine learning 5th','add':'BJ,SH,*'}
[*d1],{**d1,'date':'2019-3-30'}

# ,号放在最后的解包
l1=[[3,4,5]]
a=l1
b,=l1
print(a,b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1 2 [3, 4, 5] 6
1 [2, 3, 4, 5] 6





[1, 2, 3, 4, 'c', 'h', 'i', 'n', 'a', 'h', 'a', 'd', 'o', 'o', 'p', '.', 'c', 'n']






(['name', 'add'], {'name': 'machine learning 5th', 'add': 'BJ,SH,*', 'date': '2019-3-30'})



[[3, 4, 5]] [3, 4, 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Python基本数据类型与数据结构

基本数据类型：数值型

#数值整型
a=100;b=200

#进制转换
a=0b0101001#bin()
b=0o4#oct()
c=0x28#hex()

#浮点型
pi=3.1415

#科学计算法
c=5e13
print(c)

#数字的正负无穷
#float('inf')正无穷
#float('-inf')负无穷
if 99999999999999999<float('inf'):
    print('you win!')

#复数
a=4.3+22j
type(a)


#数值类型转换
a=4.48
b=8
int(a)

# 保留n位小数四舍五入
round(pi,3)
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

50000000000000.0
you win!





<class 'complex'>






4






3.142
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

基本数据类型：字符串型

##字符串型 单引号 双引号 三引号
#初始化及转义
str1='''AI'''
str2='chinahadoop.cn'

#访问,索引及切片访问
str2[-1]

#str2[start:end:stride]
#切片访问的特点：左闭右开[)
#012345...
str2[0:4] #从index为0取到index为4(不包括4)
str2[1:] #从index为1到结尾
str2[:4] #从开头到index为4(不包括4)
str2[0::2] #从index为0到结尾，每隔2-1=1个字符取一次

#格式化访问1
companyName='chinahadoop'
str3='http://{}.cn'
print(str3.format(companyName))

#格式化访问2
print("Company name is %s" %companyName)

#格式化访问3
_='Python 3.6'#fstring only can be used under version 3.6
str4=f"fstring is new feature of {_}"
str4    
        
#查找与替换
str3.find('o')
str3.replace('.cn','.net')

#统计
str3.count('cn')
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

'n'






'chin'






'hinahadoop.cn'






'chin'






'ciaaopc'



http://chinahadoop.cn
Company name is chinahadoop





'fstring is new feature of Python 3.6'






-1






'http://{}.net'






1
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

基本数据类型：布尔型

a=3
b=5
a<3
1
2

False
1

Python数据结构

列表/List

#列表[]:任意元素类型对象的序列
l1=['AI','chinahadoop.cn']
l2=[1,'china',l1,'机器学习集训营']
l2
1
2
3

[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营']
1

# 列表切片
l2[0] #第1个元素
l2[1] #第2个元素
l2[1:3] #左闭右开
l2[1:] #从index为1开始到结尾
l2[:3] #从index为0开始到index为2
l2[::2] #从最左开始每隔1个
1
2
3
4
5
6

1






'china'






['china', ['AI', 'chinahadoop.cn']]






['china', ['AI', 'chinahadoop.cn'], '机器学习集训营']






[1, 'china', ['AI', 'chinahadoop.cn']]






[1, ['AI', 'chinahadoop.cn']]
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

# 列表追加
l2.append(['last', 'elem']) #追加1个元素
l2
l2.extend(['new', 'item']) #追加列表
l2
l2 + l1 #追加列表
1
2
3
4
5

[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营', ['last', 'elem']]






[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营', ['last', 'elem'], 'new', 'item']






[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营', ['last', 'elem'], 'new', 'item', 'AI', 'chinahadoop.cn']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 列表删除元素
l2.pop() #返回最尾部元素，并删除该元素
l2.remove('china') #移除列表中的某个值的第一个匹配项，没有返回值
1
2

'item'
1

# 字符串列表的拼接与分割
l3 = ['I', 'love', 'China']
"_".join(l3) #用下划线拼接列表元素(需要是字符串)
a = "#".join(l3)
a
a.split("#") #用井号切分字符串生成列表
1
2
3
4
5

'I_love_China'






'I#love#China'






['I', 'love', 'China']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 列表排序
my_list = [5,1,2,4,3]
my_list.sort() #对my_list排序，直接改变my_list
my_list
new_list = [5,1,2,4,3]
sorted(new_list) #对new_list排序，以返回值返回排序结果，并不改变new_list
new_list
1
2
3
4
5
6

[1, 2, 3, 4, 5]






[1, 2, 3, 4, 5]






[5, 1, 2, 4, 3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# sorted高级用法
tmp_strs = ['aa', 'BBc', 'CCdd', 'zzmm']
sorted(tmp_strs) #按照字母序排序
sorted(tmp_strs, reverse=True) #按照字母序降序排序
sorted(tmp_strs, key=len) #根据key对元素做处理后的结果对原序列排序，这里的len是函数，返回字符串长度
sorted(tmp_strs, key=str.lower) #根据小写后的结果字母序排序
1
2
3
4
5

['BBc', 'CCdd', 'aa', 'zzmm']






['zzmm', 'aa', 'CCdd', 'BBc']






['aa', 'BBc', 'CCdd', 'zzmm']






['aa', 'BBc', 'CCdd', 'zzmm']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

元组/tuple

#元组()tuple,只读列表
t1=(1,2,3,4)
type(t1)
#只读列表是真的只读吗？
t2=(1,2,3,[4,5,6])
t2[0]=11#报错
1
2
3
4
5

<class 'tuple'>




---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-30-5a12797f04b9> in <module>()
      4 #只读列表是真的只读吗？
      5 t2=(1,2,3,[4,5,6])
----> 6 t2[0]=11#报错


TypeError: 'tuple' object does not support item assignment
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

tup = ('physics', 'chemistry', 1997, 2000)
tup1 = (50,) #元组中只包含一个元素时，需要在元素后面添加逗号
tup[1:] #元组的切片拼接和list一样
1
2

(<class 'int'>, <class 'tuple'>)
1

集合/set

#集合{}set：无序的不重复元素,集合中的对象，通常叫key
s1={1,1,1,2,3,4,5,2,4,234}
l2=[1,1,1,2,3,4,5,2,4,234]
set(l2)
1
2
3

{1, 2, 3, 4, 5, 234}
1

字典

# 字典是另一种可变容器模型，且可存储任意类型对象。
# 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
my_dict = {'HanXiaoyang': 1234, 'Jason': 4567, 'David': 6789} #定义字典
ks = my_dict.keys() #取出所有的key
ks
vs = my_dict.values() #取出所有的values
vs
Hv = my_dict['HanXiaoyang'] #根据key取对应的value
Hv
Dv = my_dict.get('XiaoMing', 2345) #根据key去取value，如果key不存在返回默认值
Dv
my_dict['HanXiaoyang'] = 7890 #改变字典中key对应的value值
my_dict
flag = 'DaDa' in my_dict #判断是否有某个key
flag

# 遍历字典元素
for key in my_dict:
    print(key,my_dict[key])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

dict_keys(['HanXiaoyang', 'Jason', 'David'])






dict_values([1234, 4567, 6789])






1234






2345






{'HanXiaoyang': 7890, 'Jason': 4567, 'David': 6789}






False



HanXiaoyang 7890
Jason 4567
David 6789
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
37
38
39
40
41
42

# 注意，字典是一种键值对数据结构，本身是无序的，如果需要顺序，可以用OrderedDict
od1=OrderedDict()#按主键首次插入顺序进行排序
od1['a']=7
od1['z']=8
od1['b']=9
od1
1
2
3
4
5

声明Statement与Expression表达式

statement声明

a='小象学院'#statement通常为赋值语句
b=100
c=a
1
2

expression表达式（通常有返回结果 ）

#值、变量和运算符共同组成的整体我们将其称为表达式。通常有值表达式、变量表达式、计算表达式、字符串表达式,
b,b+100,a+' is amazing',__builtins__
1

exec执行声明语句,eval执行表达式

exec('a=5')
a
b=3
eval('a+b+5')
1
2
3

13
1

判断，循环与循环控制

判断逻辑

#### 判断：if， if else ,if elif与三元表达式

#单if
age=88
if age<18:
    print('teenage')
    
#if else elif
if age<18:
    print('teenage')
else:
    print('adult')
    
#if elif
if age<18:
    print('teenage')
elif age >18 and age <60:
    print('adult')
elif age>60:
    print('elder')


#三元表达式
'a' if age>50 else 'b'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

循环逻辑

#For循环
str1='小象学院机器学习'
for item in str1:
    print(item)
print("")

#While循环
countnum=1
while(countnum<5):
    print(countnum)
    countnum+=1    
print("")

#### break与continue循环控制     
i=0
while True:
    i+=1
    if i==3:
        continue
    if i>5:
        break
    print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

小
象
学
院
机
器
学
习

1
2
3
4

1
2
4
5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

扩展：列表推导式List Comprehensions，可迭代对象Iterable与迭代器iterator,生成器generator

#列表推导式：从一个列表中生成一个新的列表，简化了循环的写法
l1= [x+1 for x in range(30) if x%3==0] #新的list中的元素，来源于从0-29这个list中所有整除3的元素+1
l1
1
2

[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]
1

l1=[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
l2=iter(l1)
l2.__next__()
1
2

0
1

#可迭代对象Iterable：可以被for循环的对象统称为可迭代对象Iterable,list,str,dict这些都是可迭代类型
#迭代器Iterator：可以被next调用的迭代器。
#next(l1) #TypeError: 'list' object is not an iterator

#使用iter将一来个可迭代对象变为迭代器
l1=iter(l1)
next(l1),next(l1)


#生成器Generator：首先是一个迭代器，然后其内容是按需生成
#列表是一次性生成，缺点是当内容过大时会占用大量内容，那能不能用到多少生成多少呢？
#Python里一边循环一边计算(惰性计算)的迭代器称为生成器（Generator）

#1.直接从列表表达式生成
g1= (x**2 for x in range(30) if x%2==0)
type(g1)
next(g1),next(g1),next(g1),next(g1),g1.__next__(),g1.__next__()

#2.函数生成，与yield关键字
def g2_func(n):
    for i in range(n):
        yield i**2
    
g2=g2_func(7)
next(g2),next(g2),g2.__next__(),g2.__next__(),g2.__next__(),g2.__next__()

#yield from/子迭代器，后面直接是可迭代对象。
def yield_from_iter(iter_object):
    yield from iter_object
    
y1=yield_from_iter('China')
y1.__next__(),next(y1)
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

异常与调试

#一个出现异常的例子
a=12
b=0
print(a/b)
print(12/6)
1
2
3
4

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

<ipython-input-49-10dfecf82e87> in <module>()
      2 a=12
      3 b=0
----> 4 print(a/b)
      5 print(12/6)


ZeroDivisionError: division by zero
1
2
3
4
5
6
7
8
9
10
11
12

异常/exception对象

异常同样也是Python对象，表示一个在程序执行过程中发生了影响正常运行时而产生的一个事件(产生一个traceback.)

|常见异常|说明|
|—