实验楼-python3简明教程笔记

 #!/usr/bin/env python3
 days = int(input("Enter days: "))
 print("Months = {} Days = {}".format(*divmod(days, 30)))

divmod(num1, num2) 返回一个元组，这个元组包含两个值，第一个是 num1 和 num2 相整除得到的值，第二个是 num1 和 num2 求余得到的值，然后我们用 * 运算符拆封这个元组，得到这两个值。

---

a, b = b, a + b

含义：将 a + b 的值赋值给 b，b 的值赋值给 a

解释：Python 中赋值语句执行时会先对赋值运算符右边的表达式求值，然后将这个值赋值给左边的变量

---

默认情况下，print() 除了打印你提供的字符串之外，还会打印一个换行符，所以每调用一次 print() 就会换一次行。

你可以通过 print() 的另一个参数 end 来替换这个换行符：

print('wonker', end=' ')

---

我们来写一个程序计算幂级数：e^x = 1 + x + x^2 / 2! + x^3 / 3! + ... + x^n / n! （0 < x < 1）。

#!/usr/bin/env python3
x = float(input("Enter the value of x: "))
n = term = num = 1
result = 1.0
while n <= 100:
    term *= x / n  　　#x^3 / 3! =  x^2 * x / 2! * 3;化简后即 T = t * x/n
    result += term
    n += 1
    if term < 0.0001:
        break
print("No of Times= {} and Sum= {}".format(n, result))

---

print("-" * 50)

字符串若是乘上整数 n，将返回由 n 个此字符串拼接起来的新字符串。例：

>>> 's' * 10
'ssssssssss'
>>> print("*" * 10)
**********

---

列表切片：

切片时的索引是在两个元素之间 。左边第一个元素的索引为 0，而长度为 n 的列表其最后一个元素的右界索引为 n。

 +---+-----+-----+---------+----------+
 | 1 | 342 | 223 | 'India' | 'Fedora' |
 +---+-----+-----+---------+----------+
   0    1     2       3        4          5
  -5   -4    -3      -2       -1

上面的第一行数字给出列表中的索引点 0...5。第二行给出相应的负索引。切片是从 i 到 j 两个数值表示的边界之间的所有元素。

对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如 a[2:4] 是 2。

Python 中有关下标的集合都满足左闭右开原则，切片中也是如此，也就是说集合左边界值能取到，右边界值不能取到。

对上面的列表， a[0:5] 用数学表达式可以写为 [0,5) ，其索引取值为 0,1,2,3,4，所以能将a中所有值获取到。 你也可以用a[:5], 效果是一样的。

而a[-5:-1]，因为左闭右开原则，其取值为 -5,-4,-3,-2 是不包含 -1 的。

为了取到最后一个值，你可以使用 a[-5:] ，它代表了取该列表最后5个值。

 

for 循环我们通常与 range() 函数配合使用，要特别注意的是，range() 函数返回的并不是列表而是一种可迭代对象。

python 中 for 循环的 else 子句给我们提供了检测循环是否顺利执行完毕的一种优雅方法。

---

列表相关操作函数：

insert(位置下标，元素)：插入元素　　　　count(元素) 返回元素在列表中的出现次数　　　　remove(元素)删除元素，或del list[i]　　　　

reverse()反转列表　　　　extend(另一列表名)将一个列表的所有元素添加到另一个列表的末尾　　　　sort()排序

---

---

append(元素)在末尾追加元素　　pop(i)将第i个元素弹出--->pop()弹出栈顶元素，pop(0)弹出队头元素

列表推导式【用来简易构建for循环】

形式：[表达式 for 变量 in 列表]    或者  [表达式 for 变量 in 列表 if 条件]

列表推导式由包含一个表达式的中括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。

结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。列表推导式也可以嵌套。

squares = list(map(lambda x: x**2, range(10))) 　　等价于 　　squares = [x**2 for x in range(10)]

---

---

lambda表达式【用来简易构建函数】

1、简单理解：

g = lambda x:x+1
g(1) >>>2
lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数体，用函数来表示为：

1 def g(x):
2     return x+1
另一种使用方式：
lambda x:x+1(1)　　>>>2

# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
    return arg + 1

# 执行函数
result = func(123)

# ###################### lambda ######################

# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1

# 执行函数
result = my_lambda(123)

---

---

内置函数示例

一、map【映射】map(function, iterable, ...)

遍历序列，对序列中每个元素进行操作，最终获取新的序列。

###
li = [11, 22, 33]
new_list = map(lambda a: a + 100, li)
###
li = [11, 22, 33]
sl = [1, 2, 3]
new_list = map(lambda a, b: a + b, li, sl)

二、filter【过滤器】filter(function, iterable)

对于序列中的元素进行筛选，最终获取符合条件的序列

li = [11, 22, 33]

new_list = filter(lambda arg: arg > 22, li)

#filter第一个参数为空，将获取原来序列

Python3 divmod() 函数

Python divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。

---

元组

元组是不可变类型，这意味着你不能在元组内删除或添加或编辑任何值。

要创建只含有一个元素的元组，在值后面跟一个逗号。

>>> a = (123)
>>> a
123
>>> type(a)
<class 'int'>
>>> a = (123, )
>>> b = 321,
>>> a
(123,)
>>> b
(321,)
>>> type(a)
<class 'tuple'>
>>> type(b)
<class 'tuple'>

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

集合对象还支持 union（联合），intersection（交），difference（差）和 symmetric difference（对称差集）等数学运算。

大括号或 set() 函数可以用来创建集合。注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典。

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 你可以看到重复的元素被去除
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False

>>> # 演示对两个单词中的字母进行集合操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 去重后的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # a 有而 b 没有的字母
{'r', 'd', 'b'}
>>> a | b                              # 存在于 a 或 b 的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # a 和 b 都有的字母
{'a', 'c'}
>>> a ^ b                              # 存在于 a 或 b 但不同时存在的字母
{'r', 'd', 'b', 'm', 'z', 'l'}

　###从集合中添加或弹出元素：

>>> a = {'a','e','h','g'}
>>> a.pop()  # pop 方法随机删除一个元素并打印
'h'
>>> a.add('c')
>>> a
{'c', 'e', 'g', 'a'}

字典

---

---

字符串

split() 允许有一个参数，用来指定字符串以什么字符分隔（默认为 " "），它返回一个包含所有分割后的字符串的列表。

方法 join() 使用指定字符连接多个字符串，它需要一个包含字符串元素的列表作为输入，然后连接列表内的字符串元素。

格式化操作符（%）

print("my name is %s.I am %d years old" % ('Shixiaolou',4))

%s 字符串（用 str() 函数进行字符串转换）　　　　　　%r 字符串（用 repr() 函数进行字符串转换）

%d 十进制整数　　　　%f 浮点数　　　　%% 字符“%”

---

函数

函数内使用global声明全局变量

---

文件处理

使用 read() 方法一次性读取整个文件。　　　　使用 read() 方法一次性读取整个文件。　　　　使用 read() 方法一次性读取整个文件。

执行程序 空格隔开了这三个参数，sys.argv[0]==./copyfile.py　　　　sys.argv[1]==sample.txt　　　　sys.argv[2]==sample2.txt

---

---

getcwd() 函数返回当前工作目录。chdir(path) 则是更改当前目录到 path

if __name__ == '__main__': 这条语句，它的作用是，只有在当前模块名为 __main__ 的时候（即作为脚本执行的时候）才会执行此 if 块内的语句。换句话说，当此文件以模块的形式导入到其它文件中时，if 块内的语句并不会执行。

---

每层缩进使用4个空格。

续行与圆括号、中括号、花括号这样的被包裹元素保持垂直对齐

2.8.3.1 应该避免的名字

永远不要使用单个字符l(小写字母 el)，O(大写字母 oh)，或I(大写字母 eye)作为变量名。

在一些字体中，这些字符是无法和数字1和0区分开的。试图使用l时用L代替。

2.8.3.2 包和模块名

模块名应该短，且全小写。如果能改善可读性，可以使用下划线。Python 的包名也应该短，全部小写，但是不推荐使用下划线。

因为模块名就是文件名，而一些文件系统是大小写不敏感的，并且自动截断长文件名，所以给模块名取一个短小的名字是非常重要的 – 在 Unix 上这不是问题，但是把代码放到老版本的 Mac， Windows，或者 DOS 上就可能变成一个问题了。

用 C/C++ 给 Python 写一个高性能的扩展(e.g. more object oriented)接口的时候，C/C++ 模块名应该有一个前导下划线。

2.8.3.5 全局变量名

（我们希望这些变量仅仅在一个模块内部使用）这个约定有关诸如此类的变量。

若被设计的模块可以通过from M import *来使用，它应该使用__all__机制来表明那些可以可导出的全局变量，或者使用下划线前缀的全局变量表明其是模块私有的。

2.8.3.6 函数名

函数名应该是小写的，有必要的话用下划线来分隔单词提高可读性。

2.8.3.7 函数和方法参数

总是使用self作为实例方法的第一个参数。

总是使用cls作为类方法的第一个参数。

如果函数参数与保留关键字冲突，通常最好在参数后面添加一个尾随的下划线，而不是使用缩写或胡乱拆减。因此class_比clss要好。（或许避免冲突更好的方式是使用近义词）

2.8.3.8 方法名和实例变量

用函数名的命名规则：全部小写，用下划线分隔单词提高可读性。

用一个且有一个前导的下划线来表明非公有的方法和实例变量。

2.8.3.9 常量

常量通常是模块级的定义，全部大写，单词之间以下划线分隔。例如MAX_OVERFLOW和TOTAL。

为了更好的支持内省，模块应该用__all__属性来明确规定公有 API 的名字。设置__all__为空list表明模块没有公有 API。

甚至与__all__设置相当，内部接口（包、模块、类、函数、属性或者其它的名字）应该有一个前导的下划线前缀。

被认为是内部的接口，其包含的任何名称空间（包、模块或类）也被认为是内部的。

字符串拼接用在库中性能敏感的部分，用''.join形式来代替，而不是a += b。

比较单例，像None应该用is或is not，从不使用==操作符。

• 始终使用def语句来代替直接绑定了一个lambda表达式的赋值语句。

  好的:def f(x): return 2*x 　　不好的:f = lambda x: 2*x

• 用''.startswith()和''.endswith()代替字符串切片来检查前缀和后缀。

  startswith()和endswith()是更简洁的，不容易出错的。例如：

Yes: if foo.startswith('bar'):
No:  if foo[:3] == 'bar':

• 对象类型的比较应该始终使用isinstance()而不是直接比较。

Yes: if isinstance(obj, int):

No:  if type(obj) is type(1):

---

python中yield的用法详解——最简单，最清晰的解释

生成器表达式和列表推导式的区别: 

　　1. 列表推导式比较耗内存. 一次性加载. 生成器表达式几乎不占用内存. 使用的时候才分配和使用内存

　　2. 得到的值不一样. 列表推导式得到的是一个列表. 生成器表达式获取的是一个生成器.

生成器的惰性机制: 生成器只有在访问的时候才取值. 说白了. 你找他要他才给你值. 不找他要. 他是不会执行的.

　　列表推导式:

lst = [i for i in range(1, 15)]
print(lst)

列表推导式的常用写法:     

　　[ 结果 for 变量 in 可迭代对象]

 生成器表达式和列表推导式的语法基本上是一样的. 只是把[]替换成() 

gen = (i for i in range(10))
print(gen) 

结果:
<generator object <genexpr> at 0x106768f10> 

yield和return的关系和区别“”带yield的函数是一个生成器，而不是一个函数了，这个生成器有一个函数就是next函数，next就相当于“下一步”生成哪个数，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从foo函数的开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，此步就结束。

func(*args, **kwargs)

*args, **kwargs表示函数的可变参数

*args 表示任何多个无名参数，它是一个tuple

**kwargs 表示关键字参数，它是一个dict

def foo(*args,**kwargs):
　　print 'args=',args
　　print 'kwargs=',kwargs
　　print '**********************'

if __name__=='__main__':
　　foo(1,2,3)
　　foo(a=1,b=2,c=3)
　　foo(1,2,3,a=1,b=2,c=3)
　　foo(1,'b','c',a=1,b='b',c='c')

---

---

---

你还记得我们经常使用的 pip 命令吗？有没有想过这些包是从哪里来的？答案是 PyPI。这是 Python 的软件包管理系统。

为了实验，我们会使用 PyPI 的测试服务器 https://testpypi.python.org/pypi。

2.4.1 创建账号

首先在这个链接注册账号。你会收到带有链接的邮件，点击这个链接确认你的注册。

创建 ~/.pypirc 文件，存放你的账号详细信息，其内容格式如下：

[distutils]
index-servers = pypi
    testpypi

[pypi]
repository: https://upload.pypi.org/legacy/
username: <username>
password: <password>

[testpypi]
repository:https://test.pypi.org/legacy/
username: <username>
password: <password>

 

替换 <username> 和 <password> 为您新创建的帐户的详细信息。在这里，由于我们是到 testpypi的网页上去注册账号，即将相应的服务上传到 testpypi，所以在这里，你只需修改[testpypi]的用户名和密码

记得在 setup.py 中更改项目的名称为其它的名字来测试下面的指令，在接下来的命令中我将项目名称修改为factorial2，为了不重复，大家需要自行修改至其它名称（不要使用 factorial 和 factorial2，因为已经被使用了）。

2.4.2 上传到 TestPyPI 服务

下一步我们会将我们的项目到 TestPyPI 服务。这通过 twine 命令完成。

我们也会使用 -r 把它指向测试服务器。

$ sudo pip3 install twine
$ twine upload dist/* -r testpypi

 

执行完毕会返回类似下面的信息：

Uploading distributions to https://test.pypi.org/legacy/
Uploading factorial2-0.1.tar.gz

 

现在如果你浏览这个页面，你会发现你的项目已经准备好被别人使用了。

在这里你也可以使用下面的命令上传到 PyPI 服务上，但这里需要注意，在 ~/.pypirc 里面，你需要到 https://pypi.python.org页面，按照上面的步骤去注册一个账号，然后到~/.pypirc 的 [pypi] 下填写相应的用户名和密码。testpypi 和 pypi 的账号密码并不通用。

$ twine upload dist/* -r pypi