python3学习（from 实验楼

---

运算符和表达式：

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

divmod(num1,num2)返回一个元组，这个元组包含两个值，num1 // num2和num1 % num2，*的作用是拆封这个元组。

数据结构：

列表：

py可以使用负的索引；

当切片的上下限不合理时，python可以自行处理，eg当上限<下限时返回空。

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

len(list)可以获得列表的长度；

if list可以直接判断列表是否为空

列表允许嵌套；

列表的一些方法：

py列表的部分函数

name	func
listname.append(45)	把45加到list尾部
listname.insert(pos, k)	在索引为pos处插入k
listname.count(k)	返回list中k的个数
listname.remove(k)	在list中移除k(只会移除一个)
listname.reverse()	翻转整个列表
lis1.extend(list2)	list1会变为list1+list2
listname.sort()	sort
del listname(pos)	删除list中索引为pos的值

listname.pop()可以从结尾依次弹出列表中的值；可以用作栈

listname.pop(0)可以从列表首部依次弹出列表中的值；可以用作队列

列表推导式：

squares = list(map(lambda x: x**2, range(10)))

等价于

squares = [x**2 for x in range(10)]

还可以这样：
 [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

想要遍历列表时获得对应的索引：

>>> for i, j in enumerate(['a', 'b', 'c']):
...     print(i, j)
...
0 a
1 b
2 c

如果需要同时遍历两个序列类型：

>>> a = ['Pradeepto', 'Kushal']
>>> b = ['OpenSUSE', 'Fedora']
>>> for x, y in zip(a, b):
...     print("{} uses {}".format(x, y))
...
Pradeepto uses OpenSUSE
Kushal uses Fedora

元组

1-由数个逗号分割的值组成；

2-任何元组都可以经过拆封后赋给多个值；

3-元组是不可变类型，不能在元组内更改任何值

集合

>>> 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'}

setname.pop()和setname.add()可以操作集合；

字典

1-字典是无序的键值对集合，同一字典内的建必须是互不相同的；

2-可以试用版 del;删除某一键值对: del zidianname[key]

3-dict可以从包含键值对的元组中创建字典：

>>> dict((('Indian','Delhi'),('Bangladesh','Dhaka')))
{'Indian': 'Delhi', 'Bangladesh': 'Dhaka'}

4-可以使用item遍历字典

>>> data
{'Kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}
>>> for x, y in data.items():
...     print("{} uses {}".format(x, y))
...
Kushal uses Fedora
Jace uses Mac
kart_ uses Debian
parthan uses Ubuntu

5-防止 索引的键值不存在可以使用：

>>> data['foo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'foo'
>>> data.get('foo', 0)#如果foo不存在就会返回0
0

字符串

字符串方法

str.title（）	str第一个字母大写其他小写
s.upper(), s.lower()	全部大写，全部小写
s.swapcase()	大to 小, 小to 大
s.isalnum()	如果s只含有字母和数字，则返回true
s.isalpha()类似于这种的函数还有isdigit等	如果s只含有字母则返回true
s.split(char)	返回以char分割的字符串列表，默认char为space
s.join()	用于连接, eg. >>> "-".join("GNU/Linux is great".split()) 'GNU/Linux-is-great'
s.find(s1)	在s中查找s1
s.startswith(s1)     s.endswith(s1)	s是否以s1开头；s是否以s2结尾

函数

def 函数名(参数):
    语句1
    语句2

默认参数值：

>>> def test(a , b=-99):
...     if a > b:
...         return True
...     else:
...         return False
#当调用test时如果不给b的值就会默认b=-99
#使用默认参数需要注意：具有默认参数值后面不能再有其他参数，test(a,b=-99,c)这样定义是不对的; 默认参#数值只能被赋值一次，所以当默认值是可变对象时会有如下情况:
>>> def f(a, data=[]):
...     data.append(a)
...     return data
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]

可以这样避免：
>>> def f(a, data=None):
...     if data is None:
...         data = []
...     data.append(a)
...     return data
...
>>> print(f(1))
[1]
>>> print(f(2))
[2]

强制关键字参数：

>>> def hello(*, name='User'):
...     print("Hello", name)
...
>>> hello('shiyanlou')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: hello() takes 0 positional arguments but 1 was given
>>> hello(name='shiyanlou')
Hello shiyanlou

高阶函数可以接受其他函数做参数；

一个常用的高阶函数--map: 接受一个函数和一个序列作为输入，返回一个序列（输入序列被操作后的结果）；

文件处理

使用open函数打开文件, a代表追加；close关闭文件；

fobj = open("filename")

fobj.close()

异常

常见的一些异常比如：NameError, TypeError等

处理异常：

try:
    statements to be inside try clause
    statement2
    statement3
    ...
except ExceptionName:
    statements to evaluated in case of ExceptionName happens


#raise可以抛出异常，如下：
>>> try:
...     raise ValueError("A value error happened.")
... except ValueError:
...     print("ValueError in our code.")
...
ValueError in our code.


#finally作为可选，不管有没有异常都会被执行，当有异常没被捕获时，finally执行后还是会抛出；

类

定义类：

class nameoftheclass(parent_class):
    statement1
    statement2
    statement3

通常类内定义__init__（）函数初始化；

py中尽量不要使用属性读取方法，直接读取or set

模块

导入模块：

import module

from module import *（导入模块中的定义

包：

一个包下可以有多个模块

os模块：

os.getpid()#返回当前进程id
os.getcwd()#获得当前工作目录

Collections模块

Counter类：

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['b','b','a', 'a', 'a', 'a']


#most_common()返回最常见的元素及其计数，顺序为最常见到比较不常见..
>>> Counter('abracadabra').most_common(3)
[('a', 5), ('r', 2), ('b', 2)]

defaultdict类：

defaultdict比dict.setdefault快；

nametuple类

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])  # 定义命名元组
>>> p = Point(10, y=20)  # 创建一个对象
>>> p
Point(x=10, y=20)
>>> p.x + p.y
30
>>> p[0] + p[1]  # 像普通元组那样访问元素
30
>>> x, y = p     # 元组拆封
>>> x
10
>>> y
20