廖雪峰摘录 二轮1

1、浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的

2、整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。

3、

如果字符串内部有很多换行,用\n写在一行里不好阅读,为了简化,Python允许用‘‘‘...‘‘‘的格式表示多行内容,可以自己试试:

>>> print(‘‘‘line1
... line2
... line3‘‘‘)
line1
line2
line3

4、空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。

变量的概念基本上和初中代数的方程变量是一致的,只是在计算机程序中,变量不仅可以是数字,还可以是任意数据类型。

变量在程序中就是用一个变量名表示了,变量名必须是大小写英文、数字和_的组合,且不能用数字开头

5、

Python解释器干了两件事情:

  1. 在内存中创建了一个‘ABC‘的字符串;
  2. 在内存中创建了一个名为a的变量,并把它指向‘ABC‘

也可以把一个变量a赋值给另一个变量b,这个操作实际上是把变量b指向变量a所指向的数据

6、

你没有看错,整数的地板除//永远是整数,即使除不尽。要做精确的除法,使用/就可以。

因为//除法只取结果的整数部分,所以Python还提供一个余数运算,可以得到两个整数相除的余数、

7、UTF-8编码有一个额外的好处,就是ASCII编码实际上可以被看成是UTF-8编码的一部分,所以,大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

>>> t = (‘a‘, ‘b‘, [‘A‘, ‘B‘])
>>> t[2][0] = ‘X‘
>>> t[2][1] = ‘Y‘
>>> t
(‘a‘, ‘b‘, [‘X‘, ‘Y‘])

最后来看一个“可变的”tuple:

表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向‘a‘,就不能改成指向‘b‘,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

8、

1 >>> classmates.insert(1, ‘Jack‘)
2 >>> classmates
3 [‘Michael‘, ‘Jack‘, ‘Bob‘, ‘Tracy‘, ‘Adam‘]

在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。

9、如果传入的参数数量是对的,但参数类型不能被函数所接受,也会报TypeError的错误,并且给出错误信息:str是错误的参数类型

10、

int()函数可以把其他数据类型转换为整数

如果想定义一个什么事也不做的空函数,可以用pass语句:

def nop():
    pass

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

10、

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

但其实这只是一种假象,Python函数返回的仍然是单一值:

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。

11、

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

但其实这只是一种假象,Python函数返回的仍然是单一值:

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。

12、必选参数在前,默认参数在后。

13、

Python函数在定义的时候,默认参数L的值就被计算出来了,即[],因为默认参数L也是一个变量,它指向对象[],每次调用该函数,如果改变了L的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的[]了。

所以,定义默认参数要牢记一点:默认参数必须指向不变对象!

要修改上面的例子,我们可以用None这个不变对象来实现:

def add_end(L=None):
    if L is None:
        L = []
    L.append(‘END‘)
    return L

1 def add_end(L=[]): 2 L.append(‘END‘) 3 return L

如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做:

>>> nums = [1, 2, 3] >>> calc(nums[0], nums[1], nums[2]) 14

这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去:

>>> nums = [1, 2, 3] >>> calc(*nums) 14

13、

Python的函数具有非常灵活的参数形态,既可以实现简单的调用,又可以传入非常复杂的参数。

默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误!

要注意定义可变参数和关键字参数的语法:

*args是可变参数,args接收的是一个tuple;

**kw是关键字参数,kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法:

可变参数既可以直接传入:func(1, 2, 3),又可以先组装list或tuple,再通过*args传入:func(*(1, 2, 3))

关键字参数既可以直接传入:func(a=1, b=2),又可以先组装dict,再通过**kw传入:func(**{‘a‘: 1, ‘b‘: 2})

使用*args**kw是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名,同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*,否则定义的将是位置参数。

14、。如果一个函数在内部调用自身本身,这个函数就是递归函数。

15、字符串‘xxx‘也可以看成是一种list,每个元素就是一个字符。因此,字符串也可以用切片操作,只是操作结果仍是字符串:

1 >>> ‘ABCDEFG‘[:3]
2 ‘ABC‘
3 >>> ‘ABCDEFG‘[::2]
4 ‘ACEG‘

16、如何判断一个对象是可迭代对象呢?方法是通过collections模块的Iterable类型判断:

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

17、

1 >>> [x * x for x in range(1, 11)]
2 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
3
4
5 >>> [x * x for x in range(1, 11) if x % 2 == 0]
6 [4, 16, 36, 64, 100]
7
8 >>> [m + n for m in ‘ABC‘ for n in ‘XYZ‘]
9 [‘AX‘, ‘AY‘, ‘AZ‘, ‘BX‘, ‘BY‘, ‘BZ‘, ‘CX‘, ‘CY‘, ‘CZ‘]

18、

我们创建了一个generator后,基本上永远不会调用next(),而是通过for循环来迭代它,并且不需要关心StopIteration的错误。

generator非常强大。

19、a, b = b, a+b

# 这种赋值,先计算等值 右边 那么 b=1 a+b=1

# 再赋值给a和b,那么 a=1, b=1

20、如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator

难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。

21、

生成器都是Iterator对象,但listdictstr虽然是Iterable,却不是Iterator

listdictstrIterable变成Iterator可以使用iter()函数:

1 >>> isinstance(iter([]), Iterator)
2 True
3 >>> isinstance(iter(‘abc‘), Iterator)
4 True

22、

这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。

凡是可作用于for循环的对象都是Iterable类型;

凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;

集合数据类型如listdictstr等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的

23、:函数本身也可以赋值给变量,即:变量可以指向函数。

24、

函数名也是变量

那么函数名是什么呢?函数名其实就是指向函数的变量!对于abs()这个函数,完全可以把函数名abs看成变量,它指向一个可以计算绝对值的函数!

25、既然变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

26、map()传入的第一个参数是f,即函数对象本身。由于结果r是一个IteratorIterator是惰性序列,因此通过list()函数让它把整个序列都计算出来并返回一个list。

1 >>> def f(x):
2 ...     return x * x
3 ...
4 >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
5 >>> list(r)
6 [1, 4, 9, 16, 25, 36, 49, 64, 81]

27、

In [18]: def str2num(s):
   ....:     return {‘0‘:0,‘1‘:1,‘2‘:2,‘3‘:3,‘4‘:4,‘5‘:5,‘6‘:6,‘7‘:7,‘8‘:8,‘9‘:9}[s]
   ....:

In [19]: reduce(fn,map(str2num,‘3156‘))
Out[19]: 3156

注意[s]

28、

Python内建的filter()函数用于过滤序列。

map()类似,filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。

29、

一个函数可以返回一个计算结果,也可以返回一个函数。

返回一个函数时,牢记该函数并未执行,返回函数中不要引用任何可能会变化的变量。

30、

关键字lambda表示匿名函数,冒号前面的x表示函数参数。

匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果。

用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突。此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数

31、装饰器未看!

32

def int2(x, base=2):
    return int(x, base)

假设要转换大量的二进制字符串,每次都传入int(x, base=2)非常麻烦,于是,我们想到,可以定义一个int2()的函数,默认把base=2传进去:

33、functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2

1 >>> import functools
2 >>> int2 = functools.partial(int, base=2)
3 >>> int2(‘1000000‘)
4 64
5 >>> int2(‘1010101‘)
6 85

34、

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2(‘1000000‘)
64
>>> int2(‘1010101‘)
85

35、当函数的参数个数太多,需要简化时,使用functools.partial可以创建一个新的函数,这个新函数可以固定住原函数的部分参数,从而在调用时更简单。

36、

导入sys模块后,我们就有了变量sys指向该模块,利用sys这个变量,就可以访问sys模块的所有功能。

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,因为第一个参数永远是该.py文件的名称,例如:

运行python3 hello.py获得的sys.argv就是[‘hello.py‘]

运行python3 hello.py Michael获得的sys.argv就是[‘hello.py‘, ‘Michael]

37、当我们在命令行运行hello模块文件时,Python解释器把一个特殊变量__name__置为__main__,而如果在其他地方导入该hello模块时,if判断将失败,因此,这种if测试可以让一个模块通过命令行运行时执行一些额外的代码,最常见的就是运行测试。

38、

面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。

面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行。为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统的复杂度。

而面向对象的程序设计把计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理这些消息,计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中,所有数据类型都可以视为对象,当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类(Class)的概念。

39、面向对象最重要的概念就是类(Class)和实例(Instance),必须牢记类是抽象的模板,比如Student类,而实例是根据类创建出来的一个个具体的“对象”,每个对象都拥有相同的方法,但各自的数据可能不同。

40、由于类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法,在创建实例的时候,就把namescore等属性绑上去。

注意到__init__方法的第一个参数永远是self,表示创建的实例本身,因此,在__init__方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身。

有了__init__方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去:

41、和普通的函数相比,在类中定义的函数只有一点不同,就是第一个参数永远是实例变量self,并且,调用时,不用传递该参数。除此之外,类的方法和普通函数没有什么区别,所以,你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

要定义一个方法,除了第一个参数是self外,其他和普通函数一样。要调用一个方法,只需要在实例变量上直接调用,除了self不用传递,其他参数正常传入

42、如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,所以,我们把Student类改一改:

1 class Student(object):
2
3     def __init__(self, name, score):
4         self.__name = name
5         self.__score = score
6
7     def print_score(self):
8         print(‘%s: %s‘ % (self.__name, self.__score))

改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问实例变量.__name实例变量.__score了:

43、在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name____score__这样的变量名。

双下划线开头的实例变量是不是一定不能从外部访问呢?其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name,所以,仍然可以通过_Student__name来访问__name变量:

>>> bart._Student__name
‘Bart Simpson‘

但是强烈建议你不要这么干,因为不同版本的Python解释器可能会把__name改成不同的变量名。

总的来说就是,Python本身没有任何机制阻止你干坏事,一切全靠自觉。

44、

>>> bart = Student(‘Bart Simpson‘, 98)
>>> bart.get_name()
‘Bart Simpson‘
>>> bart.__name = ‘New Name‘ # 设置__name变量!
>>> bart.__name
‘New Name‘

表面上看,外部代码“成功”地设置了__name变量,但实际上这个__name变量和class内部的__name变量不是一个变量!内部的__name变量已经被Python解释器自动改成了_Student__name,而外部代码给bart新增了一个__name变量。不信试试:

>>> bart.get_name() # get_name()内部返回self.__name ‘Bart Simpson‘

45、当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样

46、当我们定义了一个类属性后,这个属性虽然归类所有,但类的所有实例都可以访问到。

47、

1 >>> hasattr(obj, ‘power‘) # 有属性‘power‘吗?
2 True
3 >>> getattr(obj, ‘power‘) # 获取属性‘power‘
4 <bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
5 >>> fn = getattr(obj, ‘power‘) # 获取属性‘power‘并赋值到变量fn
6 >>> fn # fn指向obj.power
7 <bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
8 >>> fn() # 调用fn()与调用obj.power()是一样的
9 81


时间: 2024-10-07 06:30:30

廖雪峰摘录 二轮1的相关文章

廖雪峰python摘录二轮2

1 >>> def set_age(self, age): # 定义一个函数作为实例方法 2 ... self.age = age 3 ... 4 >>> from types import MethodType 5 >>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法 6 >>> s.set_age(25) # 调用实例方法 7 >>> s.age # 测试结果 8

20200225 Java 多线程(2)-廖雪峰

Java 多线程(2)-廖雪峰 使用wait和notify 在Java程序中,synchronized解决了多线程竞争的问题.例如,对于一个任务管理器,多个线程同时往队列中添加任务,可以用synchronized加锁: class TaskQueue { Queue<String> queue = new LinkedList<>(); public synchronized void addTask(String s) { this.queue.add(s); } } 但是syn

[k]廖雪峰Git教程-笔记

-------------------------- 廖雪峰Git教程-------------------------- 01:安装Git在Windows上安装Git,官网下载,然后按默认选项安装即可;右键菜单->“Git Bash”->弹出一个命令窗口;安装完成后,还需要最后一步设置,在命令行输入:$ git config --global user.name "Your Name"$ git config --global user.email "[emai

git常用命令,参照廖雪峰老师的git教程

git的常用命令 写在开篇: 作为一个菜鸟,我想学习的最好的方式就是边学边记笔记,这里只是本人写的自己通过学习了廖雪峰老师的git教程之后自己做的笔记,个人理解,可能有失偏颇,如想学习更专业更权威的git知识,请移步廖雪峰老师的官网 一.创建git仓库 1.git init  在本地创建一个空的仓库 2.在远程创建一个项目仓库,gitHub内操作 git remote add origin ***** 通过这两个步骤,就将本地仓库与远程仓库关联起来,然后在本地coding,提交代码到远程.也可以

廖雪峰Git教程学习笔记(一)

作者及其背景:仔姜,大三学生,幼儿园英语水平,熟系Linux文件基本操作(最基础的) 文章内容或许有些疏漏之处还望各位大佬见谅,如果构成侵权或出现其他问题,请联系我邮箱:[email protected],如果需要更全的知识请移步廖老师Git教程 学习内容来源:廖雪峰Git教程:https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000 感谢廖雪峰老师提供的教程 正文开始: Git简介 什

git常用命令总结--廖雪峰老师Git教程命令总结

学习了廖雪峰老师的Git教程之后的命令总结,重点关于git和远程仓库的东西. 如果没有学过,这是传送门 下面这个图很重要 一.git初始化本地仓库和配置 echo "想输入到文件的内容,一般为# 库名字" >> README.md git init  初始化一个仓库 如果没有配置需要配置 git config --list git config --global user.email "[email protected]" git config --gl

20200225 Java 多线程(1)-廖雪峰

Java 多线程(1)-廖雪峰 多线程基础 进程和线程的关系就是:一个进程可以包含一个或多个线程,但至少会有一个线程. 操作系统调度的最小任务单位其实不是进程,而是线程.常用的Windows.Linux等操作系统都采用抢占式多任务,如何调度线程完全由操作系统决定,程序自己不能决定什么时候执行,以及执行多长时间. Java语言内置了多线程支持:一个Java程序实际上是一个JVM进程,JVM进程用一个主线程来执行main()方法,在main()方法内部,我们又可以启动多个线程.此外,JVM还有负责垃

[廖雪峰] Git 分支管理策略

通常,合并分支时,如果可能,Git 会用 Fast forward 模式,但这种模式下,删除分支后,会丢掉分支信息. 如果要强制 禁用 Fast forward 模式,Git 就会在 merge 时生成一个新的 commit,这样,从分支历史上就可以看出分支信息. 下面我们实战一下 --no-ff 方式的 git merge: 首先,仍然创建并切换 dev 分支: $ git checkout -b dev Switched to a new branch 'dev' 修改 readme.txt

我的git学习记录------------从廖雪峰老师网站的学习总结

这篇文章只用作自我学习,部分参考来自廖雪峰老师网站 mkdir 路径/文件名(d:/test)  创建文件夹 cd  路径/文件名(cd d:/test)  进入文件夹 pwd   显示当前所出位置的路径   确保全英路径(注意) cd 仓库(repository)文件路径       eg(cd d:/test) git init   初始化空的仓库,把这个目录变成git可以管理的仓库 编写一个readme.txt文件,内容如下: Git is a version control system