python菜鸟教程学习笔记

python菜鸟教程学习笔记#不含高级教程（需要什么ctrl+F搜索）

• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。eg.print(str * 2) # 输出字符串两次
  print(str + ‘你好’) # 连接字符串
• 转义符 '\'反斜杠可以用来转义，使用r可以让反斜杠不发生转义。 eg.如 r"this is a line with \n" 则\n会显示，并不是换行(不写的话\n就表示换行）
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
• 用户输入语句 input("\n\n按下 enter 键后退出。")
• 不同行语句可以用‘；’隔开，写在同一行
• 不换行输出，在变量末尾加end“ “。eg.””print( x, end=" " )；print( y, end=" " )
• 清空终端：import os；i=os.system(“cls”)
• 模块导入：于 import 的小结，以 time 模块为例：
  1、将整个模块导入，例如：import time，在引用时格式为：time.sleep(1)。
  2、将整个模块中全部函数导入，例如：from time import *，在引用时格式为：sleep(1)。
  3、将模块中特定函数导入，例如：from time import sleep，在引用时格式为：sleep(1)。
  4、将模块换个别名，例如：import time as abc，在引用时格式为：abc.sleep(1)。
• 字符串str想转换成整型要先转换成浮点型float再转换成整型int
• 运算：2**5：2的5次方；2//4：2除以4向下取整；17%3取余

9//2 #4
9//2 #-5

• 复数表示：a+bj或complex（a,b），a,b均为浮点型。注：python不支持复数
• 字符串
  
  字符串不可修改值
• 列表list：用[]表示，内部元素类型可以不同，用逗号隔开，可用+拼接，可修改（若改为[]即为删），可截取eg.list[a：b：c]#序号a到序号b之间以c为步长截取，c为负则反向取值
• 元祖（用（）定义）除了不能赋值和列表差不多，包含的list可变，一个元素的元祖要多加个逗号

tuple = (2,)

• 集合set用{}或set（）定义，二者有所不同：

a = set(“abcd”) #a={‘c’, ‘d’, ‘a’, ‘b’} 注：这个输出没有顺序
b = {“abcd”} #b={‘abcd’} 注：这个输出没有顺序
注：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
set可用集合运算：差‘-’，和‘+’，并‘|’，交‘&’

• 位运算：与‘&’，或‘|’，异或‘^’,取反‘~’，左移右补零‘<<<’,右移左补零‘>>>’
• is用来判断a与b是否引用同一个对象

a = [1, 2, 3]
b = a
b is a #True
b == a #True

b = a[:]
b is a #False
b == a #True

• 删除对象：del
• 进制：
  2 进制是以 0b 开头的: 例如: 0b11 则表示十进制的 3
  8 进制是以 0o 开头的: 例如: 0o11 则表示十进制的 9
  16 进制是以 0x 开头的: 例如: 0x11 则表示十进制的 17
• 数学函数
  abs(x)，返回数字的绝对值，如abs(-10) 返回 10，输入复数则返回复数的模
  ceil(x)，返回数字的上入整数，如math.ceil(4.1) 返回 5
  exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
  fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
  floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
  log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0，底数为e
  log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
  max(x1, x2,…) 返回给定参数的最大值，参数可以为序列。
  min(x1, x2,…) 返回给定参数的最小值，参数可以为序列。
  modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
  pow(x, y) x**y 运算后的值。
  round(x [,n]) 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
  sqrt(x) 返回数字x的平方根。
• 随机函数：
  choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
  randrange (start, stop ,step) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1，范围包括[start]不包括stop

randrange(0,100, 2) # 从0-100中随机选取一个偶数
randrange(0,100, 4) # 从0-100中随机选取一个能被4整除的整数
randrange(1,100, 3) # 从0-100中随机选取一个能被3整除后余1的数
randrange(1, 100, 2) # 从0-100中随机选取一个奇数

random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

• 转义字符\
• 字符串可用运算符‘+’，‘*’，可切片[],可截取[:]，检测成员‘in’或‘not in’
• 字符串格式化：
  1.可用%s：

>>>name = ‘Runoob’
>>>‘Hello %s’ % name
‘Hello Runoob’

2.python3.6版本之后可用f{}

>>> name = ‘Runoob’
>>> f’Hello {name}’ # 替换变量

>>> f’{1+2}’ # 使用表达式
‘3’

• 列表操作

list[]切片，list[a:b]切段，可直接修改，删除del，组合列表+，重复列表*，直接嵌套，元素个数len（list），最大值max（list），最小值min（list），将元祖转换为列表list（seq），末尾增添对象list.append（obj），统计元素出现呢次数list.count(obj),末尾增添另一序列多个值list.extend(seq),排序list.sort()#正序、list.sort（reverse=True），列表排序。列表中不同类型可能无法比较

• 元祖，与列表相似但其中元素不能修改，元祖创建用（）或啥也不用，列表用[],元素之间用逗号隔开，若创建时只有一个元素也要在元素后面加个逗号否则就不是元祖类型了。切片切段用的还是[]。同列表一样可以使用+组合，用*复制，用in判断是否存在，用for x in （……）：来迭代，

元祖内置函数：
len（tuple）计算元祖个数；
max（tuple）返回元祖中元素最大值
min（tuple）返回元祖中元素最小值
tuple（list）将list转化为tuple

• 字典，格式：dic = {key1 : value1, key2 : value2 };访问字典dict[key];跟新字典key里的内容，dic[‘key’]=…;新增条目，dic[newkey]=…;删除key，del key；清空字典，dic.clear();删除字典del dic；键值不能重复，不能用列表当键值其他可以。

字典内置函数
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典，以可打印的字符串表示。
通过value取键值的方法
>>> dic={“a”:1,“b”:2,“c”:3}
>>> list(dic.keys())[list(dic.values()).index(1)]
‘a’
dict.copy() 返回字典的浅复制，对父对象进行深拷贝对子对象进行浅拷贝，深度拷贝需要import copy再用，函数copy.deepcopy(dic)
eg：
dict1 = {‘user’:‘runoob’,‘num’:[1,2,3]}

dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
 
#修改 data 数据
dict1['user']='root'
dict1['num'].remove(1)
 
#输出结果
print(dict1)
print(dict2)
print(dict3)

结果：
{
     'user': 'root', 'num': [2, 3]}
{
     'user': 'root', 'num': [2, 3]}
{
     'user': 'runoob', 'num': [2, 3]}

集合：集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。集合自动去重复，用‘……’ in set判断元素是否在集合里，集合可用和+，差-，并|，交&运算。基本操作：

s.update(a,b,c…) # 添加元素a,b,c,…
s.remove(a) # 移除元素a若a不存在则会报错
s.discard(“……”)#移除元素，不存在不会报错
s.pop()随机删除元素
len（s）#计算元素个数
s.clear() #清空集合
x in s 判断x是否在s中
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集 x.difference(y) #返回x和y的不同元素
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。x.symmetric_difference_update(y) #x中与y相同的元素去除，并把y中不同的元素插入到x，y不变
union() 返回两个集合的并集
update() 给集合添加元素

• end可用于将结果输出到同一行，或者在输出的末尾添加不同的字符print(a,end=’……’)
• seq设置字符串之间的分隔符
  
• if条件语句：if——elif——else，可嵌套
• while循环语句：while——else——
• for循环语句，可遍历任何序列的项目，如列表或字符串，break可跳出循环，continue跳出当前循环剩余语句直接进入下一循环
• range（）函数，生成数列。可用于循环，for i in range(5)；for i in range(5,9)；可指定步长，for i in range(0, 10, 3)；可用来创建列表，list(range(5))；
• 迭代器基本方法：iter()和next()，迭代提供了一种不依赖索引的迭代取值方式更节省内存，同一时刻内存中只存在一个值；但是不能取某个确定的 值，只能往后取，无法预测迭代器的长度。StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况
  eg:

>>> list=[1,2,3,4]
>>> it = iter(list) # 创建迭代器对象
>>> print (next(it)) # 输出迭代器的下一个元素
1
>>> print (next(it))
2

iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成；next() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

依次输出1~20

• 生成器：使用了 yield 的函数被称为生成器（generator），生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield后面（元祖类型）的值, 并在下一次执行 next() 方法时从当前位置继续运行。生成器的本质就是迭代器。

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
        ```
-  面向对象：
>python的构造函数__init__()会在对象初始化（实例化）时会自动执行
>类包括属性和方法。
>实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
>类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self（其他名字也行），self代表的就是类的实例，就是当前对象的地址，self.class指向类.
>继承，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法
```python
实例(Python 3.0+)
#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

子类可重写父类同名函数，
子类不重写构造方法__init__,实例化子类时会自动调用父类定义的__init__，重写__init__可用super调用父类构造方法：

super(子类，self).__init__(参数1，参数2，....)
或
父类名称.__init__(self,参数1，参数2，...)

类的私有属性：__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

• 可更改(mutable)与不可更改(immutable)对象。在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是 可以修改的对象（类似指针的传递）。在函数的参数传递中，不可变类型是传递了复制了的对象，对源对象无影响，而传递的可变对象是将源对象真正的传了过去。
• 函数参数传递，默认按顺序传递，也可通过fun（变量名1=变量1，变量名2=变量2）这样指定变量。如果调用过程中没有传递参数会使用默认参数，默认参数在变量声明的时候会给。若需要函数处理比声明时更多的参数，则要用不定长参数。不定长参数前加*，会以元祖的形式导入;不定长参数前加**,会以字典的形式导入；*也可单独出现,但*之后的参数必须用关键字传入

#!/usr/bin/python3
#可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
#调用printinfo 函数
printinfo( 70, 60, 50 )

输出: 
70
(60, 50)

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

输出: 
1
{
     'a': 2, 'b': 3}

• 匿名函数，python 使用 lambda 来创建匿名函数，可简化代码。格式：lambda 参数 冒号 表达式。比如：lambda x: x+1 #传入参数+1的函数
• 列表list

方法：
list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]

#演示
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

结合list.append()和list.pop()可用列表实现堆栈（后进先出）；结合list.append()和list.popleft()可用列表实现队列（先进先出）。但用列表实现队列的效率不高，因为移除一个之后其他元素得一个一个移动

• 列表推导式

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

• del在列表中依据索引来删除元素，可删除片段，del list[a:b],也可删除实体变量
• 元祖，元组由若干逗号分隔的值组成，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

• 集合，集合是无序不重复的集合，支持和差交并，支持推导式（同列表）
• 字典，创建用{}或set（），添加可直接用dic[“a”]=b,删除用del dic[“a”]，列出键值list(dic.keys()),键值排序sorted(dic.keys()),检索键值“a” in dic即可。字典的其他创建方式：

#用构造函数dic（）直接从键值对元祖列表中构建字典
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{
     'sape': 4139, 'jack': 4098, 'guido': 4127}

#此外，字典推导可以用来创建任意键和值的表达式词典：
>>> {
     x: x**2 for x in (2, 4, 6)}
{
     2: 4, 4: 16, 6: 36}

#如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：
>>> dict(sape=4139, guido=4127, jack=4098)
{
     'sape': 4139, 'jack': 4098, 'guido': 4127}

• 遍历技巧

#在这里插入代码片`遍历字典时，关键字和对应点值可以用items()方法同时解读出来：
>>> knights = {
     'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

#在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

#同时遍历两个或更多的序列，可以使用 zip() 组合：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.
要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

#要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

• 模块mod，导入方式import mod，从模块导入函数，form mod import function，导入模块所有内容from mod import *不包括私有变量私有函数。模块除了方法（函数）还有可执行的程序。自己写的模块也可以用于导入。

我有个代码名称为 test1.py，它的所在路径为 D:\test 下面。那我只需要完成以下步骤就可以把它作为模块 import 到其他代码中了。
1.import sys
2.sys.path.append(“D:\test”)
在 test2.py 中我们就可以直接 import test1.py 了。

• name 放在模块内部，若想模块引入时某一程序不执行可用其来使该模块自身运行时执行
  每个模块都有__name__和__main__,当__name__的值是__main__时，表明该模块自身在运行，否则只是引入。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

```bash
运行
$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>

• dir()函数，dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回，如果未给参数则返回当前定义的所有名称
• 标准模块，python本身带着的一些标准的模块库
• 包，是一种管理python模块命名空间的形式，采用“点模块名称”，这是你不用担心不同库之间模块重名的情况。包可以类似文件夹可以嵌套，目录只有包含一个叫做 init.py 的文件才会被认作是一个包。调用方式推荐使用from Package import specific_submodule ，不推荐from package import *除非package里面有__all__函数定义了所有模块的名称，否则很可能会出现模块重名等错误，调用举例：

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

#用户可以每次只导入一个包里面的特定模块，比如:
import sound.effects.echo
#这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

#还有一种导入子模块的方法是:
from sound.effects import echo
#这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:
echo.echofilter(input, output, delay=0.7, atten=4)

#还有一种变化就是直接导入一个函数或者变量:
from sound.effects.echo import echofilter
#同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)
#注：当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

• 输出格式，str（）函数返回一个用户易读的表达形式；repr（）函数产生一个解释器易读的表达形式。格式函数。
• .formate()格式化字符串

#大括号里的字符对应formate（）内的顺序，也可以使用关键字
>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google
>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。
#!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化:
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

#可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位：
>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
常量 PI 的值近似为 3.142。
#如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
#最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :
>>> table = {
     'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3

• input读取键盘输入

#!/usr/bin/python3
str = input("请输入：");
print ("你输入的内容是: ", str)

结果：
请输入：菜鸟教程
你输入的内容是:  菜鸟教程

• 读写文件，open(filename, mode)

filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。还有r+,w,w+,a,a+,ab…

例程

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()

f.write(string)将string写入文件中，然后返回写入的字符数，如果类型不是字符串要陷阱性转换
f.read(size)读取；f.readline() 从文件中读取所有行，可通过设置sizehint肚子知道你个长度的字节，并按行分割
另一种读取行的方式
for line in f:
print(line, end=’’)
f.tell()返回文件对象当前所处的位置，从头文件算起的字节数
f.seek(),如果要改变文件内当前的位置, 可以使用 f.seek(offset, from_what) 函数from_what（默认为0）为0时从开头开始，为1时从当前位置开始，为2时从末尾开始移动，offset为正时向后移，为负时向前移。在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'

文件处理完之后用.close()函数关闭文件释放系统资源。
用with关键字，在结束后会自动帮你关闭文件在这里插入代码片

>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

• pickle，python中的pickle模块实现了基本的数据序列和反序列化。作用是将python的对象保存为序列。且可将序列转换为python对象。
• file对象

file 对象使用 open 函数来创建,open(file, mode=‘r’)file为相对或绝对路径，mode为文件打开模式
file.read([size])，从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size]),读取整行，包括 “\n” 字符。
file.tell()，返回文件当前位置。
file.write(str)，将字符串写入文件，返回的是写入的字符长度。

• os文件/目录方法

1
os.access(path, mode)
检验权限模式
2
os.chdir(path)
改变当前工作目录
3
os.chflags(path, flags)
设置路径的标记为数字标记。
4
os.chmod(path, mode)
更改权限
5
os.chown(path, uid, gid)
更改文件所有者
6
os.chroot(path)
改变当前进程的根目录
7
os.close(fd)
关闭文件描述符 fd
8
os.closerange(fd_low, fd_high)
关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9
os.dup(fd)
复制文件描述符 fd，duplication复制
10
os.dup2(fd, fd2)
将一个文件描述符 fd 复制到另一个 fd2
11
os.fchdir(fd)
通过文件描述符改变当前工作目录
12
os.fchmod(fd, mode)
改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13
os.fchown(fd, uid, gid)
修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14
os.fdatasync(fd)
强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15
os.fdopen(fd[, mode[, bufsize]])
通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16
os.fpathconf(fd, name)
返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17
os.fstat(fd)
返回文件描述符fd的状态，像stat()。
18
os.fstatvfs(fd)
返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19
os.fsync(fd)
强制将文件描述符为fd的文件写入硬盘。
20
os.ftruncate(fd, length)
裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21
os.getcwd()
返回当前工作目录current work dir
22
os.getcwdu()
返回一个当前工作目录的Unicode对象
23
os.isatty(fd)
如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24
os.lchflags(path, flags)
设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25
os.lchmod(path, mode)
修改连接文件权限
26
os.lchown(path, uid, gid)
更改文件所有者，类似 chown，但是不追踪链接。
27
os.link(src, dst)
创建硬链接，名为参数 dst，指向参数 src
28
os.listdir(path)
返回path指定的文件夹包含的文件或文件夹的名字的列表。
29
os.lseek(fd, pos, how)
设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30
os.lstat(path)
像stat(),但是没有软链接
31
os.major(device)
从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32
os.makedev(major, minor)
以major和minor设备号组成一个原始设备号
33
os.makedirs(path[, mode])
递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34
os.minor(device)
从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35
os.mkdir(path[, mode])
以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36
os.mkfifo(path[, mode])
创建命名管道，mode 为数字，默认为 0666 (八进制)
37
os.mknod(filename[, mode=0600, device])
创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38
os.open(file, flags[, mode])
打开一个文件，并且设置需要的打开选项，mode参数是可选的
39
os.openpty()
打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40
os.pathconf(path, name)
返回相关文件的系统配置信息。
41
os.pipe()
创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42
os.popen(command[, mode[, bufsize]])
从一个 command 打开一个管道
43
os.read(fd, n)
从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44
os.readlink(path)
返回软链接所指向的文件
45
os.remove(path)
删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46
os.removedirs(path)
递归删除目录。
47
os.rename(src, dst)
重命名文件或目录，从 src 到 dst
48
os.renames(old, new)
递归地对目录进行更名，也可以对文件进行更名。
49
os.rmdir(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50
os.stat(path)
获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51
os.stat_float_times([newvalue])
决定stat_result是否以float对象显示时间戳
52
os.statvfs(path)
获取指定路径的文件系统统计信息
53
os.symlink(src, dst)
创建一个软链接
54
os.tcgetpgrp(fd)
返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55
os.tcsetpgrp(fd, pg)
设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56
os.tempnam([dir[, prefix]])
Python3 中已删除。返回唯一的路径名用于创建临时文件。
57
os.tmpfile()
Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58
os.tmpnam()
Python3 中已删除。为创建一个临时文件返回一个唯一的路径
59
os.ttyname(fd)
返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60
os.unlink(path)
删除文件路径
61
os.utime(path, times)
返回指定的path文件的访问和修改的时间。
62
os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
输出在文件夹中的文件名通过在树中游走，向上或者向下。
63
os.write(fd, str)
写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64
os.path 模块
获取文件的属性信息。

• 异常处理，

可用try/except语句

首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
如果没有异常发生，忽略 except 子句，try 子句执行后结束。
如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
如果一个异常没有与任何的 excep 匹配，那么这个异常将会传递给上层的 try 中。
可以使用多个except来处理不同错误，也可以用同一个except处理多种错误。

import sys
 
try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

try/except…else，这样可以处理一些except无法捕获的异常

try-finally 语句，try-finally 语句无论是否发生异常都将执行最后的代码。

• glob，glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

• shutil模块为文件管理，文件目录提供很多好用的方法，例如

shutil.copyfile(src, dst) #将src文件内容复制至dst文件(拷贝文件)
shutil.copy(src, dst)： 将文件src复制至dst。dst可以是个目录，会在该目录下创建与src同名的文件，若该目录下存在同名文件，将会报错提示已经存在同名文件。权限会被一并复制。本质是先后调用了copyfile与copymode而已.(拷贝文件和权限)
shutil.move(src, dst)： 将src移动至dst目录下。若dst目录不存在，则效果等同于src改名为dst。若dst目录存在，将会把src文件夹的所有内容移动至该目录下面

• random提供了生成随机数的工具,举例

>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

• urlib.request和smtlib分别可用来处理互联网网页数据和发送电子邮件
• datetime模块用于处理时间日期和格式化输出
• 数据压缩，以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile
• timeit用于性能度量，比如用timeit。Timer测量程序运行时间
• 测试模块，doctest模块可根据模块内嵌的文档字符串执行测试；unittest模块可在一个独立的文件里提供一个更全面的测试集。
• 菜鸟实例https://www.runoob.com/python3/python3-examples.html
  Python Hello World 实例
  Python 数字求和
  Python 平方根
  Python 二次方程
  Python 计算三角形的面积
  Python 计算圆的面积
  Python 随机数生成
  Python 摄氏温度转华氏温度
  Python 交换变量
  Python if 语句
  Python 判断字符串是否为数字
  Python 判断奇数偶数
  Python 判断闰年
  Python 获取最大值函数
  Python 质数判断
  Python 输出指定范围内的素数
  Python 阶乘实例
  Python 九九乘法表
  Python 斐波那契数列
  Python 阿姆斯特朗数
  Python 十进制转二进制、八进制、十六进制
  Python ASCII码与字符相互转换
  Python 最大公约数算法
  Python 最小公倍数算法
  Python 简单计算器实现
  Python 生成日历
  Python 使用递归斐波那契数列
  Python 文件 IO
  Python 字符串判断
  Python 字符串大小写转换
  Python 计算每个月天数
  Python 获取昨天日期
  Python list 常用操作
  Python 约瑟夫生者死者小游戏
  Python 五人分鱼
  Python 实现秒表功能
  Python 计算 n 个自然数的立方和
  Python 计算数组元素之和
  Python 数组翻转指定个数的元素
  Python 将列表中的头尾两个元素对调
  Python 将列表中的指定位置的两个元素对调
  Python 翻转列表
  Python 判断元素是否在列表中存在
  Python 清空列表
  Python 复制列表
  Python 计算元素在列表中出现的次数
  Python 计算列表元素之和
  Python 计算列表元素之积
  Python 查找列表中最小元素
  Python 查找列表中最大元素
  Python 移除字符串中的指定位置字符
  Python 判断字符串是否存在子字符串
  Python 判断字符串长度
  Python 使用正则表达式提取字符串中的 URL
  Python 将字符串作为代码执行
  Python 字符串翻转
  Python 对字符串切片及翻转
  Python 按键(key)或值(value)对字典进行排序
  Python 计算字典值之和
  Python 移除字典点键值(key/value)对
  Python 合并字典
  Python 将字符串的时间转换为时间戳
  Python 获取几天前的时间
  Python 将时间戳转换为指定格式日期
  Python 打印自己设计的字体
  Python 二分查找
  Python 线性查找
  Python 插入排序
  Python 快速排序
  Python 选择排序
  Python 冒泡排序
  Python 归并排序
  Python 堆排序
  Python 计数排序
  Python 希尔排序
  Python 拓扑排序