复习神器,廖雪峰的官网

Python学习/复习神器–>种种方法/技艺在哪用和独立例证(一),python–

就自己个人在读书Python的长河中,日常会产出学习了新办法后,借使隔上几天不用,就忘了的图景,或然刚上学的越来越好的格局未有拿走应用,依旧沿用已有些艺术,那样很不便利学习和精晓新姿态,进而扩大学习时间,扩张学习费用。

为此,作者认为有至关重要把种种措施照旧本事的用处和其高高在上例证记录下来,方便在闲暇时间阅读,并在实际操作上创造采纳,对提升调整新姿态的效能会很有裨益。

留神:以下基于Python3

基础篇

一、数据类型

1.list中追法郎素,追新币素到最终:list.append(‘成分’)、插入到钦点的职分:list.insert(‘索引号’,‘成分’);删除末尾的成分:list.pop、删除内定地点的因素:list.pop(‘索引号’)

2.input()返回的数据类型是str

3.迭代/循环:for x in …
 
把各种成分代入变量x,然后实行缩进块的说话

4.dict中幸免key不设有的错误2种艺术,1、通过in剖断key是或不是留存:’Jia’ in
dict  重回Ture或False  
2、通过dict提供的get()方法:dict.get(‘Yannan’);删除成分:dict.pop(key)

5.set:和dict类似,也是一组key的成团,但不存款和储蓄value。由于key不能重新,所以,在set中,未有重新的key。要开创二个set,要求提供多少个list作为输入集合:s
= set([1,2,3]).

添美成分:s.add(key)
 
 删除成分:s.remove(key)。set能够视作数学意义上的冬日和无重复成分的聚众,由此,五个set能够做数学意义上的错落有致、并集等操作:交集&
   并集 |

6.列表倒序方法:list = [3,5,4]    list.sort()    >>[3,4,5]

7.字符串的元素代替格局:s = ‘abc’  s.replace(‘a’,’A’)  
>>’Abc’    谨记变量s仍是’abc’  
原因是replace艺术创制了一个新的字符串’Abc’

二、函数

1.函数名其实就是指向二个函数对象的援引,完全可以把函数名赋给一个变量,相当于给这些函数起了三个“外号”:ads(-100)
>>100    a = abs    a(-67) >>67

2.空函数

1 def nop():
2     pass

pass语句什么都不做,那有怎么着用?实际上pass能够用来作为占位符复习神器,廖雪峰的官网。,比方未来还没想好怎么写函数的代码,就能够先放一个pass,让代码能运营起来。

pass还是能用在任何语句里,比方:

1 if age >=18:
2     pass

缺点和失误了pass,代码运营就能够有语法错误。

3.函数能够并且重临几个值,但实则正是三个tuple

4.函数试行完成也远非return语句时,自动return None

5.假使有不能缺少,能够先对参数的数据类型做检讨

6.除了符合规律定义的必选参数外,仍是能够接纳暗中同意参数可变参数、关键字参数和取名主要字参数**,使得函数定义出来的接口,不但能管理复杂的参数,还足以简化调用者的代码

7.总结x的n次方的艺术,使用while循环

1 def power(x, n):
2     s = 1
3     while n > 0:
4         n = n - 1
5         s = s * x
6     return s

8.可变参数   计算a2 + b2 + c2 + ……

1 def calc(*numbers):
2     sum = 0
3     for n in numbers:
4         sum = sum + n * n
5     return sum

9.最首要字参数   

可变参数允许你传入0个或随意个参数,这几个可变参数在函数调用时自动组装为多少个tuple。而首要字参数允许你传入0个或自由个含参数名的参数,那么些重大字参数在函数内部自行组装为多个dict

1 def person(name, age, **kw):
2     print('name:', name, 'age:', age, 'other:', kw)

珍惜字参数有怎样用?它能够增加函数的坚守。譬喻,在person函数里,我们保险能接过到nameage那三个参数,可是,固然调用者愿意提供更加多的参数,大家也能选择。试想你正在做三个客户注册的效果,除了客户名和年龄是必填项外,别的都以可挑选,利用重大字参数来定义这么些函数就能够满意注册的急需。

10.取名首要字参数  
 
命名的严重性字参数是为了限制调用者能够流传的参数名,同期能够提供私下认可值。

1 def person(name, age, *, city, job):
2     print(name, age, city, job)

和主要字参数**kw不等,命名第一字参数要求二个离奇分隔符**背后的参数被视为命名首要字参数

11.递归函数   总计阶乘n!

1 def fact(n):
2     if n==1:
3         return 1
4     return n * fact(n - 1)

递归函数的亮点是概念简单,逻辑清晰。理论上,全体的递归函数都足以写成循环的办法,但循环的逻辑不及递归清晰。缺点是过深的调用会促成栈溢出。

12.切片

L[0:3]表示,从索引0千帆竞发取,直到索引3得了,但不包涵索引3。即索引012,正好是3个元素。

L = list(range(10))  >>L[:9:2]  >>[0, 2, 4, 6, 8]    第三个数字是步长

13.迭代

在Python中,迭代是通过for ... in来产生的

迭代dict中的key、value、key和value:for key in dict、for value in
d.values()、for k,v in d.items()

什么样推断二个对象是可迭代对象啊?方法是经过collections模块的Iterable类型判别:

>>> from collections import Iterable
>>> isinstance('abc', Iterable)      # str 是否可迭代
True
>>> isinstance([1,2,3], Iterable)   # list 是否可迭代
True  
>>> isinstance(123, Iterable)        # 整数 是否可迭代
False

14.列表生成式

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还足以应用两层循环,能够生成全排列:

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

动用列表生成式,能够写出十三分轻巧的代码。举个例子,列出当前目录下的具备文件和目录名,能够透过一行代码落成:

>>> import os # 导入os模块
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录

打印dict中的 key=value,并出口叁个列表:

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

三个list中享有的字符串变成小写:

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

 15.生成器

g = (x * x for x in range(10))

>>> next(g)
0
>>> next(g)
1

generator保存的是算法,每一回调用next(g),就计算出g的下四个成分的值,直到总结到最后贰个要素,未有越多的成分时,抛出StopIteration的错误。

当然,下边这种无休止调用next(g)实质上是太变态了,准确的法子是行使for循环,因为generator也是可迭代对象

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)

之所以,大家创造了一个generator后,基本上永久不会调用next(),而是经过for循环来迭代它,况且无需关爱StopIteration的错误。

斐波拉契数列(Fibonacci),除第三个和第二个数外,自便二个数都可由前五个数相加获得:

1, 1, 2, 3, 5, 8, 13, 21, 34, …

1 def fib(max):
2     n, a, b = 0, 0, 1
3     while n < max:
4         print(b)
5         a, b = b, a + b
6         n = n + 1
7     return 'done'

16.迭代器

生成器都是Iterator对象,但listdictstr虽然是Iterable(可迭代对象),却不是Iterator(迭代器)

listdictstrIterable变成Iterator能够选用iter()函数:

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

凡是可职能于for巡回的目的都以Iterable类型;

澳门葡京备用网址,大凡可效果于next()函数的靶子都以Iterator类型,它们表示一个惰性总结的队列;

群集数据类型如listdictstr等是Iterable但不是Iterator,可是能够经过iter()函数获得二个Iterator对象。

就自身个人在念书Python的进度中,平常会并发学习了新章程后,若是…

就自个儿个人在攻读Python的经过中,平常会出现学习了新形式后,尽管隔上几天不用,就忘了的情事,大概刚上学的更加好的不二等秘书籍未有到手运用,如故沿用已部分艺术,那样很不方便人民群众学习和摆布新姿态,进而增加学习时光,扩充学习开支。

廖雪峰的官网。

Python小白的新手教程(一),python小白菜鸟教程

 本文是 python
入门级其余基础知识,包涵数据类型和变量、输入输出、字符串和编码、list
tuple dict set 、条件判定、循环、函数、切成片 迭代 列表生成器 生成器
迭代器等。

参照课程:

廖雪峰的官方网站  慕课网-python入门

参照他事他说加以考察书籍:

侯爵.《编制程序小白的第1本 Python 入门书》  


 

为此,小编觉着有不能缺少把各类方法也许本事的用途和其优秀例证记录下来,方便在闲暇时间读书,并在实际操作上成立使用,对增进调节新姿势的频率会很有利润。

请注意区分命令行方式和Python交互方式。

前言

Python 是一种相当高等的言语,通过 Python
解释器把符合语法的程序代码转变来 CPU 能够实践的机器码,然后执行。Python
特别简洁,达成同一个职务,C 语言要写  一千 行代码,Java 只供给写 100
行,而 Python 或许只要 20 行,然而 Python 的运作速度稍慢。

设置 python 后能够通过文件编辑器来保存代码
.py,通过命令行方式来运行代码,而 Python 自带的
IDLE(交互模式)能够用来证武周码。也能够直接用 IDE
集成开拓条件来编排和周转代码。

稳重:以下基于Python3

1在Python交互式格局下,能够一直输入代码,然后施行,并及时获得结果。

首先有个别 Python基础

基础篇

在命令行格局下,能够一贯运转.py文件。

数据类型和变量、输入输出、字符串和编码、list tuple dict set 、条件剖断、循环、函数、切条 迭代 列表生成器 生成器 迭代器

  1. Python 用 # 来注释,用缩进表示语法。Python 区分轻重缓急写。

    缩进根据约定俗成的习贯,持之以恒运用 4 个空格的缩进(把 tab 设置为 4
个空格)。

亮点:强迫写出缩进比较小的代码,把一段不短的代码拆分成若干函数。
短处:“复制-粘贴”作用失效,须要在 IDLE 上再也检讨缩进。

一、数据类型

2周转实际上和java运营同样 cd dir

1. 数据类型、常变量、种种运算

澳门葡京备用网址 1

1.list中追港成分,追英镑素到最终:list.append(‘成分’)、插入到钦命的职责:list.insert(‘索引号’,‘成分’);删除末尾的要素:list.pop、删除钦赐地点的因素:list.pop(‘索引号’)

3 print() input()

2. 字符串和编码

澳门葡京备用网址 2

2.input()重回的数据类型是str

4数据类型 整数 浮点数
字符串:假使字符串内部含有单引号恐怕双引号,能够用转义字符\来标识。print(‘I\’m
ok.’)I’m ok.\n换行
\t制表\\意味着的是\

3. 输入和出口

3.迭代/循环:for x in …
 
把各种成分代入变量x,然后实行缩进块的讲话

布尔值可以用and  or not运算  空值
是python里多少个奇特的值,用none表示,none不可能代表为0,而是一个自成一家的值。
  变量不能够用数字初始。   常量

3.1 输出

print('hello,world')

print('100+300=',100+300) 

print('hello ,','world')   

print('hello,'+'world') 
# 结果:hello,world 

print('bang ! '*3)
# 结果:bang ! bang ! bang !

print(type(2))
# 结果:<class 'int'> 

search = '168'
num_a = '138-6168-0006'
num_b = '168-1222-0006'
print(search + ' is at ' + str(num_a.find(search)) + ' to ' + str(num_a.find(search)+len(search)) + ' of num_a ')
print(search + ' is at ' + str(num_b.find(search)) + ' to ' + str(num_b.find(search)+len(search)) + ' of num_b ')
# 结果:
168 is at 5 to 8 of num_a 
168 is at 0 to 3 of num_b

  2. 输出三个字符串用逗号 “,” 隔绝,print()
依次打字与印刷每种字符串,境遇逗号 “,”会输出二个空格。

  3. 在 print() 函数中,”+”
在整数和浮点数中为运算符,在字符型中为连接符。字符串与整数、浮点数一齐输出必需用
“,”,不可能用 “+” 。

4.dict中防止key不设有的荒唐2种方法,1、通过in认清key是还是不是存在:’Jia’ in
dict  重返Ture或False  
2、通过dict提供的get()方法:dict.get(‘Yannan’);删除成分:dict.pop(key)

/除法计算结果是浮点数,尽管是三个整数恰好整除,结果也是浮点数。

3.2 输入

name=input('please enter your name')
print('hello,',name)

  4. 在 input() 函数中加多字符串能够提醒顾客输入内容。

5.set:和dict类似,也是一组key的集纳,但不存款和储蓄value。由于key无法重新,所以,在set中,没有再度的key。要开创一个set,供给提供八个list作为输入集结:s
= set([1,2,3]).

//称为地板除,多少个整数的除法整数依然是整数。

3.3 格式化

添澳成分:s.add(key)
 
 删除成分:s.remove(key)。set能够看做数学意义上的冬季和无重复成分的汇集,由此,多个set能够做数学意义上的和弄、并集等操作:交集&
   并集 |

5ord()函数获取字符的寸头表示,chr()函数把编码转变为相应的字符。

3.3.1 用 % 格式化

  5.  %d 整数   %f 浮点数    %s 字符串    %x
十六进制整数。

print( 'Hello, %s' % 'world')

print('Hi, %s, you have $%d.') % ('Michael', 1000000)

print('%2d-%02d' % (3, 1))   # 结果:3-01

print( '%.2f' % 3.1415926)    # 结果:3.14

  6. 有多少个 %?
占位符,前面就跟多少个变量或许值,顺序要对应好。要是独有二个%?,括号能够简简单单。

  7. 格式化整数和浮点数能够钦点是不是补 0 和整数与小数的位数。

  8. 只要不太鲜明相应用如何,%s
永恒起效果,它会把其余数据类型调换为字符串。

  9. 字符串里面包车型客车 % 是多个不足为奇字符,用 %% 来代表二个 % 。

6.列表倒序方法:list = [3,5,4]    list.sort()    >>[3,4,5]

6python保留的字符串类型是str,假如要在网络上传输,只怕封存到磁盘上,就须要把str变为以字节为单位的bytes。Python对bytes类型的数额用b前缀的单引号或双引号表示。

3.3.2 用 format 格式化

print('Hello, {}'.format('world'))
print('Hi, {}, you have ${}.'.format ('Michael', 1000000)) 

7.字符串的要素代替方式:s = ‘abc’  s.replace(‘a’,’A’)  
>>’Abc’    谨记变量s仍是’abc’  
原因是replace办法创造了一个新的字符串’Abc’

例:x=b’ABC’要留心区分’ABC’和b’ABC’,前边多个是str,前者即使内容显示得和前面贰个同样,但bytes的各类字符都只占用一个字节。

4. list 和 tuple

二、函数

在unicode表示的str通过encode()方法能够编码为拟订的bytes。把bytes变为str,须求选取decode()方法。

4.1 列表 list []

  10. list 是一种有序的集合,可以随时加多和删除在那之中的要素。 

classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)  # 结果:['Michael', 'Bob', 'Tracy']

  11. 用 len() 函数能够拿走 list 成分的个数。

print(len(classmates))  # 结果:3

  12. 顺序索引、逆序索引。

print(classmates[0],classmates[1],classmates[2])  # 结果:Michael Bob Tracy

print(classmates[-1], classmates[-2],classmates[-3])  # 结果:Tracy Bob Michael

  13. 在 list 末尾添日成分、在 list 钦定地方增加元素、增加三个元素。

classmates.append('Adam')
print(classmates)  # 结果:['Michael', 'Bob', 'Tracy', 'Adam']  

classmates.insert(1, 'Jack')
print(classmates)  # 结果:['Michael', 'Jack', 'Bob', 'Tracy']  

classmates = ['Michael', 'Bob', 'Tracy']
classmates.extend(['Adam', 'Jack'])
print(classmates)
# 结果:['Michael', 'Bob', 'Tracy', 'Adam', 'Jack']

  14. 去除 list 末尾的要素、删除钦命地点的成分。

classmates.pop()
print(classmates)  # 结果:['Michael', 'Bob']

classmates.pop(1)
print(classmates)  # 结果:['Michael', 'Tracy'] 

classmates = ['Michael', 'Bob', 'Tracy']
classmates.remove('Bob')    # 用 remove 删除要指定元素
print(classmates)

classmates = ['Michael', 'Bob', 'Tracy']
del classmates[2]
print(classmates)

  15. 更新有个别元素。

classmates[1] = 'Sarah'
print(classmates)  # 结果:['Michael', 'Sarah', 'Tracy']

  16. list 中得以分包各样数据类型。

 L = ['Apple', 123, True]

  17. 嵌套 list。

s = ['python', 'java', ['asp', 'php'], 'scheme']
print(len(s))    # 结果:4
print(s[2][0])  # 结果:asp

1.函数名其实就是指向贰个函数对象的援用,完全能够把函数名赋给二个变量,也正是给那几个函数起了多少个“小名”:ads(-100)
>>100    a = abs    a(-67) >>67

7乘除str包蕴多少个字符/bytes正是字节数,可以用len()函数

4.2 元组 tuple ()

  18. tuple 起首化后不可能修改,另外同 list (
len()、索引、能够是其他数据类型、嵌套)。

classmates = ('Michael', 'Bob', 'Tracy')

  19. 唯有1个成分的 tuple 定义时必须加三个逗号 “,”
,来排除歧义(数学计算意义上的括号)。

t = (1,)
print(t)  # 结果:(1,)

  20. "可变的"tuple (嵌套) 。

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)  # 结果:('a', 'b', ['X', 'Y'])

  21. tuple 所谓的"不改变"是说 tuple 的种种成分指向永世不改变,即针对
‘a’ ,无法改成指向 ‘b’ ,指向一个 list
,不能够改成指向任何对象,但针对的那一个 list
本人是可变的。要成立一个剧情也不改变的 tuple ,就务须确认保证 tuple
的每一个元素本人也不能够变。

                                   
 澳门葡京备用网址 3澳门葡京备用网址 4

2.空函数

8format()格式化字符串。

5. dict 和 set

1 def nop():
2     pass

9
python放置的一种数据类型是列表。list是一种有序的会合,能够随时增添和删除当中的因素。Len()能够赢得list成分的个数,索引是从0伊始的。

5.1 字典 dic {}

  22. 松手的字典,全称dictionary,在其他语言中称之为map,使用键-值(key-value)存款和储蓄,具备相当的慢的查找速度。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d['Michael'])  # 结果:95

  23. 用 len() 函数能够收获 dict 成分的个数。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(len(d))  # 结果:3

  24. 增加 key-value 、增添八个 key-value。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Adam']=67
print(d)  # 结果:{'Adam': 67, 'Bob': 75, 'Tracy': 85, 'Michael': 95}

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d.update({'Adam':67,'Jack':99})
print(d)

  25. 更新 value 。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Bob'] = 90
print(d['Bob'])  # 结果:90

  26. 删除 key-value 。dict 没有 remove

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d.pop('Bob')
print(d)  # 结果:{'Michael': 95, 'Tracy': 85} 

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
del d['Bob']
print(d)

  27. 检查 key 是否在 dict 中。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print('Thomas' in d)  # 结果:False

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print('Michael' in d)  # 结果:True

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d.get('Thomas'))  # 结果:None

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d.get('Michael'))  # 结果:95

  28. dict 追寻和插入快,占用空间大,dict 冬季;list
查找和插入慢,占用空间小,list 有序;

       dict 的 key 必需是不可变对象 (字符串、整数等都以不可变的,list
是可变的)。

pass语句什么都不做,那有啥样用?实际上pass能够用来作为占位符,比如以往还没想好怎么写函数的代码,就足以先放二个pass,让代码能运作起来。

10刨除list末尾的因素,用pop()方法。删除钦赐地点成分,用pop(i)i是索引地方

5.2 set 

  29. set 和 dict 类似,也是一组 key 的集聚,但不存款和储蓄 value。由于 key
不可能再度,所以,在 set 中,未有再一次的 key 。

  30. set 自动过滤重复的成分, set 中的成分是冬辰的。

s = set([2,1,2,3])
print(s)  # 结果:{1, 2, 3}

# {1, 2, 3} 只是告诉你这个 set 内部有 1,2,3 这 3 个元素,显示的顺序并不表示 set 是有序的

  31. 添欧成分。

s = set([2,1,2,3])
s.add(4)
print(s)  # 结果:{1, 2, 3, 4}

  32. 刨除元素。set 未有 del pop 。

s = set([2,1,2,3,4])
s.remove(4)
print(s)  # 结果:{1, 2, 3}  

s = {1,2,3,4}
s.discard(4)
print(s)

  33. 检查 key 是否在 set 中。

s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
print('adam' in s)    # 结果:False
print('Adam' in s)  # 结果:True

  34. set
可以当作数学意义上的冬日和无重复元素的聚众,因而,多个set能够做数学意义上的并、交、差操作。

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = set([1, 2, 3, 4, 5])
print(s1 & s2)   # 交      结果:{2, 3}
print(s1 | s2)   # 并      结果:{1, 2, 3, 4}
print(s3 - s1)   # 差      结果:{4, 5}  

  35. set 和 dict 的独一无二不相同仅在于未有存款和储蓄对应的 value ,不过,set
的规律和 dict 同样。set
不得以归入可变对象,因为不只怕判别七个可变对象是不是等于,也就不可能担保set
内部 “不会有重新成分”。

pass仍是能够用在其它语句里,比方:

11list里面包车型客车要素数据类型也得以不相同,成分得以是另二个list。

 5.3 再议不可变对象

a = [6,74,2,3,5,36,5]
a.sort(reverse=True)
print(a)
# 结果:[74, 36, 6, 5, 5, 3, 2]

a = ['a', 'd', 'c']
a.sort()
print(a)  # 结果:['a', 'c', 'd']

a = 'abc'
a.replace('a','A')
print(a)  # 结果:abc 

a = 'abc'
b = a.replace('a','A')
print(a)    # 结果:abc
print(b)    # 结果:Abc

  当大家调用 a.replace(‘a’,’A’) 时,实际上调用方法 replace
是职能在字符串对象 ‘abc’ 上的,而这些艺术即使名字叫
repalce,但却从未改变字符串 ‘abc’ 的剧情。相反,replace
方法创造了七个新字符串 ‘Abc’ 并重返。要是大家用变量 b
指向该新字符串,则变量 a 仍指向原有的字符串 ‘abc’,但变量 b
却指向新字符串 ‘Abc’ 了。

1 if age >=18:
2     pass

12 tuple 有类别表,一旦初叶化就无法改变。

6. 尺码判定

比较运算符 ==, !=,>, <, <=, >=
成员运算符 in,not in
身份运算符 is,is not
布尔元素符 not,and, or

  36.差别连串的目的无法选取 >, <, <=, >=
实行比较,但能够运用 ==, !=
比较。浮点数和整数可以比相当的大小。布尔类型可以非常大小,False 为 0,True
为 1。

a = 'a'
b = 'a'
print(a is b)
print(a is not b)
# 结果:
True
False

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

  36. 假若 if 语句剖断是 True ,就实行缩进的说话。注意 if、else、elif
前边的 “:” 。

  37. if
语句从上往下推断,纵然在有个别剖断上是 True ,把该论断相应的口舌实施后,就大体掉多余的
elif 和 else。

  38. if 论断标准能够简写,非零数值、非空字符串、非空 list tuple dict
set 等,都认清为 True,否则为 False 。

x = 8
if x:
    print('True')

  39. input() 重回的数据类型是 str ,str不能够间接和整数相比较,要把 str
用 int() 转为整数。

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

  当 if
前边的布尔表明式过长或然难于掌握,能够采取给变量赋值的办法来累积布尔表明式重临的布尔值
True 或 False 。

password_list = ['*#*#', '12345']
def account_login():
    password = input('Password')
    password_correct = password == password_list[-1]
    password_reset = password == password_list[0]
    if password_correct :
        print('Login success!')
    elif password_reset :
        new_password = input('Enter a new password:')
        password_list.append(new_password)
        print('Your password has changed successfully')
        account_login()
    else:
        print('Wrong password or invalid input!')
        account_login()
account_login()

缺乏了pass,代码运营就能有语法错误。

13口径语句 int()函数把str换到整数。

7. 循环

3.函数能够何况重返多个值,但实质上就是多少个tuple

14循环 for……in   while
 break功能是提前甘休循环,continue是跳过本次巡回,直接先导下贰遍巡回。

7.1 for…in 循环,遍历 list、tuple、disc、set 

  40. for x in y 生生不息正是把 y 中各样成分代入变量 x
,然后实践缩进块的话语。

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

# 对list中的每一个元素,如果在set中,就将其删除,如果不在set中,就添加进去
s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for a in L:
    if a in s :
        s.remove(a)
    else:
        s.add(a)
print(s)

# 遍历如下的dict,打印 name: score 
d = {'Adam': 95,'Lisa': 85,'Bart': 59}
for key in d :
    print(key+':',d[key])

# 遍历如下的set,打印出 name: score
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
    print(x[0] + ':', x[1])

  41. range() 函数生成整数行列,list() 函数把整数队列调换为 list。 [
set()、tuple() 同 ]

        譬喻 range(5) 生成从0开首小于5的卡尺头系列。

print(list(range(5)))  # 结果:[0, 1, 2, 3, 4]
print(set(range(5)))   # 结果:{0, 1, 2, 3, 4}

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

4.函数推行完成也未有return语句时,自动return None

15 dict()
剖断key是还是不是存在用in还应该有通过dic提供的get()方法。如果key不设有能够回到none,也许钦定的value。Pop(key)对应的value也会从dict中删去。

7.2 while 循环,条件满足时进行巡回,条件不满足时退出循环

# 计算100以内所有奇数之和
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

5.借使有供给,能够先对参数的数据类型做检讨

16set是一组key的聚合,但是不存款和储蓄value.由于key无法重复。在set中一向不再一次的key。

7.3 break 提前退出循环

n = 1
while n <= 100:
    if n > 10: # 当n = 11时,条件满足,执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

6.除了正规定义的必选参数外,还足以行使私下认可参数可变参数、关键字参数和取名第一字参数**,使得函数定义出来的接口,不但能管理扑朔迷离的参数,仍是可以简化调用者的代码

17add(key)方法可以添美元素到set中。能够再一次增加。可是没意义。remove(key)能够去除成分。

7.4 continue 跳过当前巡回,步向下一循环

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数,执行continue语句
        continue # continue语句会直接继续下一轮循环,后续的print()语句不会执行
    print(n)

  42.不要滥用 break 和 continue 语句。break 和 continue
会变成代码执行逻辑分叉过多,轻便失误。大多数生生不息并没有必要用到 break 和
continue
语句,上边的两个例证,都可以经过改写循环条件照旧涂改循环逻辑,去掉 break
和 continue 语句。

7.计算x的n次方的格局,使用while循环

18 函数 abs 相对值  max最大值函数
int其余数据类型调换为整数。Python内置函数。

7.5 嵌套循环

for x in ['A', 'B', 'C']:
    for y in ['1', '2', '3']:
        print(x + y)

# 打印出100以内所有十位数数字比个位数数字小的数
a = set(range(10))
a.remove(0)
for x in a:
    for y in a:
        if x < y:
            print(x*10+y)
        else:
            continue
1 def power(x, n):
2     s = 1
3     while n > 0:
4         n = n - 1
5         s = s * x
6     return s

19定义函数 ,python自身笔者有许多函数。官方网站有。函数参数。

8. 函数

8.可变参数   计算a2 + b2 + c2 + ……

20概念函数  def hello();define的情致,用来定义函数。

8.1 调用函数

Python内置了成都百货上千卓有效率的函数,大家能够直接调用。

abs() 返回一个数的绝对值
max() 返回多个数中最大的数
cmp(x, y) 如果 x<y,返回 -1,如果 x==y,返回 0,如果 x>y,返回 1
int() 把其他数据类型转换为整数
float() 把其它数据类型转换为浮点数
str() 把其它数据类型转换为字符串
bool() 把其它数据类型转换为布尔值
hex() 把一个整数转换成十六进制表示的字符串
list()、set()、tuple() 把某序列转换为 list、set、tuple

 对函数使用别称

a = abs # 变量a指向abs函数
print(a(-1)) # 所以也可以通过a调用abs函数
1 def calc(*numbers):
2     sum = 0
3     for n in numbers:
4         sum = sum + n * n
5     return sum

21报了名函数 enroll

8.2 定义函数

  43. 概念二个函数要动用 def
语句,依次写出函数名、括号、括号中的参数和冒号”:”,然后,在缩进块中编写函数体,函数的回到值用
return 语句重临。若无 return 语句时,自动 return None 。

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

  44.在 Python 交互遭受中定义函数时,注意 Python
会出现 ...的唤醒。函数定义结束后必要按五回回车重新赶回 >>>
提醒符下。

    澳门葡京备用网址 5

  45. 概念八个空函数,再未有想好函数代码时让总体代码能运作起来。

def nop():
    pass

# pass 也可以在其它语句
if age >= 18:
    pass

  46. 调用函数时,Python
解释器会检讨内置函数的参数个数和参数类型是或不是科学,而对自定义的函数只检查参数个数,所以我们要在函数定义中对参数类型实行检讨。数据类型检查能够用内置函数
isinstance() 落成。

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

  47. Python 的函数重临多值其实就是回去三个 tuple 。在语法上,重返三个tuple 能够省略括号,而多少个变量能够并且吸收一个 tuple
,按任务赋给对应的值。

# 给出一点的坐标,给出移动位移、角度,计算出新坐标

import math    #导入 math 包

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y + step * math.sin(angle)
    return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print(x, y)          # 结果:151.96152422706632 130.0
r = move(100, 100, 60, math.pi / 6)
print(r)             # 结果:(151.96152422706632, 130.0)

9.注重字参数   

22定义暗许参数要铭记一点:暗许参数必得指向不改变对象!

8.3 函数的参数

可变参数允许你传入0个或自由个参数,这么些可变参数在函数调用时自动组装为一个tuple。而注重字参数允许你传入0个或私行个含参数名的参数,那一个根本字参数在函数内部自行组装为三个dict

23可变参数  关键字参数
  命名关键字参数*args是可变参数,args接收的是二个tuple;

8.3.1 地点参数

# 计算一个数的平方
def power(x):
    return x * x

# 计算一个数的n次方
def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
  1. 地点参数,调用函数时,传入的八个值根据岗位顺序依次赋给参数
    x 和 n 。
1 def person(name, age, **kw):
2     print('name:', name, 'age:', age, 'other:', kw)

**kw是首要字参数,kw接收的是贰个dict。

8.3.2 默许参数

# 在不传入n时,n默认为2
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(5))    # 结果:25
print(power(5,3))    # 结果:125

49.安装默许参数时,有几点要留心:

     一是必选参数在前,私下认可参数在后,不然Python的表达器会报错;

   
 二是当函数有四个参数时,把转换大的参数放前面,变化小的参数放前面。变化小的参数就能够视作暗许参数。

50.
暗中认可参数降低调用的难度。一旦须要更复杂的调用时,又有什么不可传递越多的参数来落实。无论是轻易调用照旧复杂调用,函数只须要定义贰个。

51. 有多个私下认可参数时,调用的时候,既能按顺序提供暗中同意参数,也能够不按顺序提供一些默许参数。当不按顺序提供一些暗许参数时,要求把参数名写上。

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name,'    gender:', gender,'    age:', age,'    city:', city)

enroll('Sarah','F')  # 结果:name: Sarah     gender: F     age: 6     city: Beijing
enroll('Bob','M',7)  # 结果:name: Bob     gender: M     age: 7     city: Beijing
enroll('Adam','M',city='Changsha')  # 结果:name: Adam     gender: M     age: 6     city: Changsha

  52.
暗许参数必需指向不改变对象。因为不变对象一旦成立,对象内部的多寡就不可能修改,那样就减弱了是因为修改数据产生的不当。

def add_end(L=[]):  # 默认参数为list,为可变对象
    L.append('END')
    return L

# 正常调用
print(add_end([1, 2, 3]))        # 结果:[1, 2, 3, 'END']
print(add_end(['x', 'y', 'z']))  # 结果:['x', 'y', 'z', 'END']

# 默认调用
print(add_end())  # 结果:['END']
print(add_end())  # 结果:['END', 'END']
print(add_end())  # 结果:['END', 'END', 'END']

# 因为默认参数L也是一个变量,它指向对象[],每次调用该函数,如果改变了L的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的[]了

首要字参数有哪些用?它能够扩展函数的职能。比方,在person函数里,我们保障能接受到nameage那四个参数,不过,即便调用者愿意提供更加多的参数,我们也能收到。试想你正在做三个顾客注册的效率,除了客户名和年龄是必填项外,别的都以可挑选,利用重视字参数来定义这么些函数就可以满足注册的急需。

以及调用函数时怎么传播可变参数和关键字参数的语法:

8.3.3 可变参数

  53. 可变参数便是传播的参数个数是可变的,能够是 0
个或私下个参数,这个可变参数在函数调用时自动组装为七个 tuple 。

def calc(*numbers): # 参数前面加了一个*号。在函数内部,参数numbers接收到的是一个tuple
    sum = 0
    for n in numbers :
        sum = sum + n*n
    return sum

print(calc(1,2))
print(calc())
nums = [1, 2, 3]
print(calc(nums[0], nums[1], nums[2]))
print(calc(*nums))  # *nums表示把nums这个list的所有元素作为可变参数传进去

10.取名第一字参数  
 
命名的根本字参数是为了限制调用者可以流传的参数名,同期能够提供暗许值。

可变参数不仅可以够一向传入:func(1, 2,
3),又足以先组装list或tuple,再通过*args传入:func(*(1, 2, 3));

8.3.4 关键字参数

  54. 关键字参数允许你传入 0
个或专擅个含参数名的参数,这么些入眼字参数在函数内部自行组装为四个 dict 。

  55. 在调用该函数时,能够只传入必选参数。也能够流传大四个数的关键字参数。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

person('Michael', 30)                            # 结果:name: Michael age: 30 other: {}
person('Bob', 35, city='Beijing')                # 结果:name: Bob age: 35 other: {'city': 'Beijing'}
person('Adam', 45, gender='M', job='Engineer')   # 结果:name: Adam age: 45 other: {'job': 'Engineer', 'gender': 'M'}

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=extra['city'], job=extra['job'])   # 结果:name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)                                # 结果:name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

# **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数,kw将获得一个dict,注意kw获得的dict是extra的一份拷贝,对kw的改动不会影响到函数外的extra

  56.
默许参数是具有的调用函数都有定义的兼具参数(个数不改变),只是暗许参数的值是私下认可的;而器重字参数在调用函数时客户能够流传任意个数关键字参数(个数可变),只是需求含参数名,并且概念关键字参数在函数内部自行组装为贰个dict 。

1 def person(name, age, *, city, job):
2     print(name, age, city, job)

重大字参数不仅可以够直接传入:func(a=1,
b=2),又有啥不可先组装dict,再通过**kw传入:func(**{‘a’: 1, ‘b’: 2})。

8.3.5 命名第一字参数

  对于首要字参数,函数的调用者可以流传大肆不受限制的显要字参数。至于到底传入了什么,就要求在函数内部通过
kw 检查。以 person() 函数为例,大家盼望检查是否有 city 和 job
参数,不过调用者还能够流传不受限制的关键字参数。

def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

  57. 命名第一字参数,只接受钦定名字的首要字参数。命名第一字参数必得传入参数名。若无传来参数名,调用将报错(看作地方参数)。

  58. 命名主要字参数供给贰个异样分隔符 *,*
前边的参数被视为命名第一字参数,要是缺点和失误 *,Python
解释器将不大概识别地点参数和命名第一字参数。假设函数定义中曾经有了几个可变参数,前边跟着的命名第一字参数就不再要求一个异样分隔符
* 。

  59. 命名第一字参数能够有缺省值,进而简化调用。

def person(name, age, *, city, job):   
    print(name, age, city, job)

person('Jack', 24, city='Beijing', job='Engineer')    # 结果:Jack 24 Beijing Engineer 

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

person('Jack', 24, city='Beijing', job='Engineer')    # 结果:Jack 24 () Beijing Engineer
person('Jack', 24, 1, 2, 3, city='Beijing', job='Engineer')    # 结果:Jack 24 (1, 2, 3) Beijing Engineer

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

person('Jack', 24, job='Engineer')        # 结果:Jack 24 Beijing Engineer 

  60.
主要字参数,调用者能够传或不传关键字参数,关键字参数将要函数内部整合
dict
;命名首要字参数调用者必需传入全部的参数(定义缺省值的除了),而且亟需传入参数名,不过不结合
dict 。命名第一字参数只是限制参数的名字;

和第一字参数**kw不等,命名首要字参数必要一个特别分隔符**背后的参数被视为命名首要字参数

使用*args和**kw是Python的习贯写法,当然也足以用别样参数名,但最佳应用习贯用法。

8.3.6 参数组合

  61. 在 Python
中定义函数,能够用必选参数、暗中同意参数、可变参数、关键字参数和命名首要字参数这5
种参数组合使用。但参数定义的相继务必是:参数定义的逐条必得是:必选参数、暗中同意参数、可变参数、命名第一字参数和严重性字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

f1(1, 2)                        # 结果:a = 1 b = 2 c = 0 args = () kw = {}
f1(1, 2, 3)                     # 结果:a = 1 b = 2 c = 3 args = () kw = {}
f1(1, 2, 3, 'a', 'b')           # 结果:a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
f1(1, 2, 3, 'a', 'b', x=99)     # 结果:a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)                 # 结果:a = 1 b = 2 c = 3 args = (4,) kw = {'x': '#', 'd': 99}

# *args相当于传入tuple中的数字

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

f2(1, 2, d=99, ext=None)    # 结果:a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
args = (1, 2, 3)
kw = {'d': 88, 'x': '#'}    
f2(*args, **kw)             # 结果:a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

# 若把 kw 中的第一个 key d 改为其它会报错,因为没有传入命名关键字参数

11.递归函数   计算阶乘n!

取名的严重性字参数是为了限制调用者能够流传的参数名,同一时候能够提供默许值。

8.4递归函数

   一个函数在其间调用自身自己,那么些函数就是递归函数。规范的例证正是总括阶乘。

# n! = 1 x 2 x 3 x ... x n
# (n-1)! = 1 x 2 x 3 x ... x (n-1) 
# n! = (n-1)! x n

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

# fact(5)计算过程
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

  汉诺塔的移动可以用递归函数极其轻松地落到实处。

def move(n, a, b, c):   #将n个盘从a柱移到到c
    if n ==1:
        print(a, '-->', c)  #a柱为一个盘时,将仅有的一块盘a柱移动到c柱
        return
    else:
        move(n-1, a, c, b)  #a柱盘多于一个时,将n-1个盘从a柱移动到b柱
        print(a, '-->', c)  #当a柱剩一个盘时,将这个盘移动到c柱
        move(n-1, b, a, c)  #将n-1盘从b柱移动到c
move(4, 'a', 'b', 'c')
1 def fact(n):
2     if n==1:
3         return 1
4     return n * fact(n - 1)

概念命名的第一字参数在尚未可变参数的气象下不要忘了写分隔符*,否则定义的将是岗位参数。

9. 高等性子

递归函数的独到之处是概念轻便,逻辑清晰。理论上,全数的递归函数都足以写成循环的格局,但循环的逻辑不比递归清晰。劣点是过深的调用会促成栈溢出。

24 递归函数。

9.1 切成条 slice  取 list 、tuple、str 的局地因素

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

print(L[0:3])     # L[0:3]表示,从索引0开始取,直到索引3为止,但不包括索引3
print(L[:3])      # 如果第一个索引是0,可以省略 
print(L[1:3])     #从索引1开始,取出2个元素出来
# 结果:['Michael', 'Sarah', 'Tracy']
# 结果:['Michael', 'Sarah', 'Tracy']
# 结果:['Sarah', 'Tracy']

print(L[-3:])      # 从索引-3开始开始取,一直到结束
print(L[-3:-1])    # 从索引-3开始取,直到索引-1,但不包括-1
# 结果:['Tracy', 'Bob', 'Jack']
# 结果:['Tracy', 'Bob']

print(L[0:5:2])    # 从索引0到索引4,每2个取一个
# 结果:['Michael', 'Tracy', 'Jack']

  对 list( range() ) 取部分成分。

L = list(range(100))
print(L)
print(L[:10])    # 取前十个元素
print(L[-10:])    # 取后十个元素
print(L[11:21])  # 取11-20个元素
print(L[:20:2])    # 取前20个元素,每2个取一个
print(L[::5])    #取所有元素,每5个取一个
print(L[:])      # 取所有元素

  对 tuple、str 取部分要素。

print((0, 1, 2, 3, 4)[:3])
print('ABCDEFG'[:3])
print('ABCDEFG'[::2]) 

phone_number = '138-6666-0006'
hiding_number = phone_number.replace(phone_number[:9],'*'*9)
print(hiding_number)
# 结果:*********0006

  set 、dict 不可 slice。

12.切片

25 高档性情。

9.2 迭代  遍历可迭代对象

# 迭代 list tuple
L=[1, 2, 3, 4]
for a in L:
    print(a)

T=(1, 2, 3, 4)
for b in T
    print(b)

# 迭代 dict 的 key
d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
    print(key)
# 结果:
b
a
c
# 迭代 dict 的 value
d = {'a': 1, 'b': 2, 'c': 3}
for value in d.values():
    print(value)
# 结果:
2
3
1

# 迭代 dict 中的 key 与 value
d = {'a': 1, 'b': 2, 'c': 3}
for k, v in d.items():
    print('k:',v)
# 结果:
b: 2
c: 3
a: 1

# 迭代字符串
for ch in 'ABC':
    print(ch)
# 结果:
A
B
C

  62.
当大家采用 for 循环时,只要效能于一个可迭代对象,for 循环就足以健康运维,而不太关注该目的毕竟是
list 照旧别的数据类型。能够经过 collections 模块的 Iterable
进行项目剖断。

from collections import Iterable
print(isinstance('abc', Iterable))           # str是否可迭代
print(isinstance([1,2,3], Iterable))        # list是否可迭
print(isinstance({1, 2, 3},Iterable))       # set是否可迭代
print(isinstance({'a':2 ,'b':2},Iterable))    # dict是否可迭代
print(isinstance(123, Iterable))            # 整数是否可迭代
# 结果:True
# 结果:True
# 结果:True
# 结果:True
# 结果:False

  63. 只要要明白迭代的下标,可以应用内置的 enumerate 函数。

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
# 结果:
0 A
1 B
2 C

  64. for 循环同一时候引用多少个变量。

for x, y in [(1, 1), (2, 4), (3, 9)]:
    print(x, y)
# 结果:
1 1
2 4
3 9

for x,y in zip( ['A', 'B', 'C'],['1', '2', '3']):
    print(x + y)
# 结果:
A1
B2
C3

L[0:3]表示,从索引0千帆竞发取,直到索引3截至,但不饱含索引3。即索引012,正好是3个元素。

1切片:L[0:3]意味着,从索引0起首取,直到索引3截止,但不蕴涵索引3。即索引0,1,2,正好是3个成分。

9.3  列表生成式  

print([x * x for x in range(1, 11)])    # 生成 [1x1, 2x2, 3x3, ..., 10x10]
print([x * x for x in range(1, 11) if x % 2 == 0])    # 筛选出仅偶数的平方
# 结果:[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 结果:[4, 16, 36, 64, 100]

print([m + n for m in 'ABC' for n in 'XYZ'])    # 两层循环,生成全排列
# 结果:['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

d = {'x': 'A', 'y': 'B', 'z': 'C' }
print([k + '=' + v for k, v in d.items()])    # for循环同时使用两个变量
# 结果:['y=B', 'x=A', 'z=C']

# 通过一个复杂的列表生成式把 dict 变成一个 HTML 表格
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.items()]
print( '<table>' )
print( '<tr><th>Name</th><th>Score</th><tr>' )
print( '\n'.join(tds) )
print( '</table>' )
# 字符串的join()方法可以把一个 list 拼接成一个字符串
# 结果:
<table>
<tr><th>Name</th><th>Score</th><tr>
<tr><td>Bart</td><td>59</td></tr>
<tr><td>Lisa</td><td>85</td></tr>
<tr><td>Adam</td><td>95</td></tr>
</table>
# 把打印出来的结果保存为一个html文件,就可以在浏览器中看到效果

# lower() 函数的参数类型只能是 str ,用列表生成器修改列表 L1 ,保证lower() 正确调用
L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() for x in L1 if isinstance (x, str)]
print(L2)
# 结果:['hello', 'world', 'apple']

L = list(range(10))  >>L[:9:2]  >>[0, 2, 4, 6, 8]    第三个数字是步长

L[1:3]从索引1开头,收取2个成分出来。

9.4 生成器 generator

   列表体量有限,並且占用非常的大的仓库储存空间。通过生成器,列表成分能够遵从某种算法推算出来,能够在循环的进度中不仅仅推算出后续的要素。

13.迭代

L[-10:]后11个数

9.4.1 把列表生成式改成 generator

L = [x * x for x in range(10)]    # 列表生成器
g = (x * x for x in range(10))    # 生成器 把[]改成()
print(g)
# 结果:<generator object <genexpr> at 0x1022ef630>

  打字与印刷出 generator 的各类成分有三种艺术:一种是透过 next()
得到;二是通过 for 循环 (一般用此办法)。

# 通过 next() 打印出 generator 的每个元素
g = (x * x for x in range(3))
print(next(g))
print(next(g))
print(next(g))
print(next(g))  # 没有更多的元素时,抛出StopIteration的错误 
# 结果:
0
1
4
Tracebacke (most recent call last):
  File xxxxx,line x , in xx
StopIteration 

# 通过 for 循环来迭代
g = (x * x for x in range(3))
for n in g:            # 不会产生 StopIteration 的错误
    print(n)  
# 结果:
0
1
4

在Python中,迭代是透过for ... in来成功的

L[10:20]前11-20个数

9.4.2 通过函数实现复杂逻辑的 generator

  假诺推算的算法相比复杂,用类似列表生成式的 for
循环不可能完结的时候,还足以用函数来贯彻。

  65. generator 的函数,在历次调用 next() 的时候试行,碰着 yield
语句重临,再度施行时从上次再次来到的 yield 语句处继续实施。

# 用函数生成斐波拉契数列(除第一个和第二个数外,任意一个数都可由前两个数相加得到)1, 1, 2, 3, 5, 8, 13, 21, 34, ...

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b                              # 把函数中的 return 改为 yield,函数就变成 generator   
        a, b = b, a + b
        n = n + 1
    return 'done'

f = fib(6)
print(f)
# 结果 :<generator object fib at 0x000001F4575E30A0>

for n in f:
    print(n)
# 结果 :
1
1
2
3
5
8  

澳门葡京备用网址 6

赋值语句 a, b = b, a + b
相当于 t = ( b, a+b)   # t 是一个 tuple
    a = t[0]
           b = t[1]     # tuple 中 a+b 在父子之前就计算好了

a, b = b, a + b 的解释

# 用函数生成杨辉三角

def triangles():
    L = [1]
    while True:
        yield L
        L.append(0)
        L = [L[i-1] + L[i] for i in range(len(L))]

n = 0
for t in triangles():
    print(t)
    n = n + 1
    if n == 10:
        break       # 如果没有 break ,将无限循环
# 结果:
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

澳门葡京备用网址 7

首先杨辉三角和之前的汉诺塔一样,也要找到规律。

第N行有N个数,那么第N行就比第N-1行多出1个数,每次加上一个0可以实现这个规律,至于为什么加0,等下再说。

除了上面说的废话之外,要得出每一行具体是什么数还需要找到另外的规律,这里不能按照“肩上的两个数之和”的规律来得出,只能在本行内找规律。

另外L[i-1] + L[i]是什么意思呢?也就是前一个数加上后一个数。

下面来看实际的过程。

一开始L = [1],只有一个数,第一轮直接返回[1],第二轮开始每次都要加上一个0则:

第二轮开始 L = [1, 0] 此时列表内有2个数,i的取值范围为[0, 1],带入L[i-1] + L[i],则得到[0+1, 1+0]。实际上这是“倒数第一个数和正数第一个数的和”以及“正数第一个数和正数第二数的和”。最后得到 L = [1, 1]

第三轮开始 L = [1,1,0] 此时列表内有3个数,i的取值范围为[0, 1 ,2],带入L[i-1] + L[i],则得到[0+1, 1+1, 1+0]。实际上这是“倒数第一个数和正数第一个数的和”、“正数第一个数和正数第二数的和”以及“正数第二个数和正数第三个数的和”。最后得到L = [1, 2, 1]。

第三轮开始 L = [1, 2, 1, 0] 此时列表内有4个数,i的取值范围为[0, 1, 3],带入L[i-1] + L[i],则得到[0+1, 1+2, 2+1, 1+0]。实际上这是“倒一和正一的和”、“正一和正二的和”、“正二和正三的和”以及“正三和正四的和”。最后得到L = [1, 3, 3, 1]。

到这里规律就出来了,每次加上一个0之后,每行之间的数也就是从倒数第一个数开始每次加上前一个数的和。至于为什么加上0,因为杨辉三角形每行最后是1,而1 = 1 + 0,加上0才能使最后一个数永远是1。

之前就是不明白L[i-1] + L[i]以及为什么加0的问题,想了半天手写了一下找了一下规律茅塞顿开

杨辉三角的算法解释(来源:半分幻的凶鳥)

迭代dict中的key、value、key和value:for key in dict、for value in
d.values()、for k,v in d.items()

L[:10:2]前12个数,每三个取一个

9.5 迭代器 Iterator

  能够用 for 循环的指标统称为可迭代对象 Iterable 。满含:list tuple
dict set str / generator [isinstance(xxx,Iterable)]

  能够被 next() 函数调用并连发重回下一个值的目的称为迭代器 Iterator
。生成器都以 Iterator 对象 [isinstance(xxx,Iterator)]

  Python 的 Iterator 对象表示的是四个数据流,Iterator 对象足以被
next() 函数调用并持续重临下二个数据,直到未有数量时抛出 StopIteration
错误。能够把这一个数据流看做是二个一成不改变种类,但大家却不可能提前领略连串的长短,只好不停通过
next() 函数达成按需总括下一个数目,所以
Iterator 的计量是惰性的,唯有在急需再次回到下一个多少时它才会估摸。Iterator
乃至足以象征二个极其大的数据流,比如全部自然数。而利用 list
是永久不容许存款和储蓄全体自然数的。

  使用 iter() 函数能够把 list tuple dict set str 等 Iterable 产生Iterator。

from collections import Iterator
print(isinstance([], Iterator))     # 结果:False
print(isinstance({}, Iterator))     # 结果:False
print(isinstance('', Iterator))     # 结果:False
print(isinstance(iter([]), Iterator))     # 结果:True
print(isinstance(iter({}), Iterator))   # 结果:True
print(isinstance(iter(''), Iterator))     # 结果:True

 


何以判别叁个对象是可迭代对象啊?方法是通过collections模块的Iterable类型剖断:

L[::5]全部数,每5个取三个

  小结:

  文中对 list 、tuple、dict、set
的界别与联系写的非常不够明晰,在这边再下结论一下

  有/无序 可切片 可迭代 可列表生成 len() 删除 添加 更改
list 可[enumerate()] .pop(索引)/.remove(元素)/del [索引] .append(元素)/.insert(索引,元素)/.extend([]) [索引]=
tuple
dict 不可 可[key/.values()/.items()] .pop(key)/del [key] [key]=/.update({}) [key]=
set 不可 .remove(元素)/.discard(元素) .add(元素)

本文是 python
入门级其余基础知识,包含数据类型和变量、输入输出、字符串和编码、lis…

>>> from collections import Iterable
>>> isinstance('abc', Iterable)      # str 是否可迭代
True
>>> isinstance([1,2,3], Iterable)   # list 是否可迭代
True  
>>> isinstance(123, Iterable)        # 整数 是否可迭代
False

只写[:]就可以形容复制贰个list。

14.列表生成式

2迭代

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

3列表生成式

还能行使两层循环,能够生成全排列:

list(range(1,11))生成1到10

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

写列表生成式时,把要扭转的成分x *
x放到前面,后面跟for循环,就能够把list成立出来。[x * x for x in
range(1, 11)]改造的是平方。

使用列表生成式,可以写出卓殊轻便的代码。比方,列出当前目录下的持有文件和目录名,能够因而一行代码完结:

4生成器 generator

>>> import os # 导入os模块
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录

generator是格外有力的工具,在Python中,可以大概地把列表生成式改成generator,也足以通过函数完结复杂逻辑的generator。

打印dict中的 key=value,并出口二个列表:

要驾驭generator的劳作规律,它是在for循环的长河中不停一个钱打二十两个结出下二个因素,并在适当的尺度截止for循环。对于函数改成的generator来讲,遭遇return语句或然推行到函数体最终一行语句,便是终止generator的命令,for循环随之截止。

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

请小心区分普通函数和generator函数,普通函数调用直接回到结果

三个list中持有的字符串产生小写:

5迭代器

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

凡是可职能于for循环的指标都以Iterable类型;

 15.生成器

凡是可职能于next()函数的目的都是Iterator类型,它们表示一个惰性总括的行列;

g = (x * x for x in range(10))

>>> next(g)
0
>>> next(g)
1

汇合数据类型如list、dict、str等是Iterable但不是Iterator,可是可以经过iter()函数得到一个Iterator对象。

generator保存的是算法,每一回调用next(g),就总计出g的下叁个因素的值,直到总括到最终三个元素,未有越多的要素时,抛出StopIteration的错误。

Python的for循环本质上便是通过不停调用next()函数达成的。

理之当然,上边这种不断调用next(g)实则是太变态了,精确的办法是运用for循环,因为generator也是可迭代对象

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)

为此,大家创制了二个generator后,基本上永世不会调用next(),而是通过for循环来迭代它,并且无需关心StopIteration的错误。

斐波拉契数列(Fibonacci),除第两个和第三个数外,任意一个数都可由前五个数相加获得:

1, 1, 2, 3, 5, 8, 13, 21, 34, …

1 def fib(max):
2     n, a, b = 0, 0, 1
3     while n < max:
4         print(b)
5         a, b = b, a + b
6         n = n + 1
7     return 'done'

16.迭代器

生成器都以Iterator对象,但listdictstr虽然是Iterable(可迭代对象),却不是Iterator(迭代器)

listdictstrIterable变成Iterator能够运用iter()函数:

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

凡是可效果于for循环的指标都以Iterable类型;

大凡可职能于next()函数的靶子都以Iterator项目,它们表示二个惰性总结的队列;

会晤数据类型如listdictstr等是Iterable但不是Iterator,然则能够经过iter()函数得到八个Iterator对象。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website