Magolor 首页文章幻灯片归档标签
Python 3入门笔记
|OIPython
字数总计: 7.4k|阅读时长: 27 分钟

Python 3入门笔记。有很多东西还没有涉及。仅供参考。

求Python大佬指点。


安装(Sublime Text 3)

  • 官网下载最新版Python 3并安装。同时安装好Sublime Text 3与Sublime插件Package Control。

  • 使用Sublime插件Package Control安装插件SublimeREPL。在Package Settings中插入片段:

1
2
3
4
5
6
7
8
9
{
    "keys":["f5"],
    "caption":"SublimeREPL:Python - RUN current file",
    "command":"run_existing_window_command","args":
    {
        "id":"repl_python_run",
        "file":"config/Python/Main.sublime-menu"
    }
}
  • 用.py文件存储源代码，默认用Python打开，右键IDLE或直接双击文件运行。也可以默认用Sublime打开，F5运行。

基本情况

  • 行中、行末空格不区别，行首空格数目用于区别代码段，文末回车不区别。()，[]和{}中换行的行首空格不区别。

  • 区分大小写，变量名只能以下划线和字母开头，不能以数字开头，不能包含空格(同C++)。变量名不能包含下述字符:

    ~ ! @ # $ % ^ & * ( ) ; - : " ' < > , . ? / { } [ ] + = /

  • # COMMENT: 单行注释。可以利用三引号字符串的换行功能进行多行注释。

  • Python中的下标访问支持负下标。即一个对象a内有n个元素标号为0 ~ n-1，那么a[n]会报错，a[-1] = a[n-1]，a[-2] = a[n-2] … a[-n] = a[0]，a[-(n+1)]会报错。


输入输出

print

print(): 输出。

代码换行而输出不换行时可以使用:

1
2
print(SOMETHING1,end="")
print(SOMETHING2)

然后换行继续书写。这并不常用，更常用的方法是:

1
2
print(SOMETHING1,
      SOMETHING2)

对于三引号字符串可以有:

1
2
print('''SOMETHING1
SOMETHING2''')

但在循环中则只能被迫使用第一种方法，如:

1
2
for i in range(0,5):
  print(i,end=" ")

输出0 1 2 3 4。

直接用逗号分割可以以空格为分隔输出多个对象。

1
print(1,2,3,4,5)

输出1 2 3 4 5。

input

input(): 输入得到一个字符串(整行)，可以强制类型转换，如a = int(input())。

可以使用input("aaa")表示先输出提示语aaa然后进行一次输入。

file

open(name,mode,buffering,encoding)返回一个file对象。name表示要访问的文件名称(地址)；mode有r只读，r+读写，w清空只写，w+清空读写，a追加只写，a+追加读写，加b表示二进制文件。buffering表示寄存区的缓冲大小，默认或一个复数则为系统默认。

a.read(x): 读入x个字符。a.read()默认读入整个文件。读到文件结尾时返回空字符串""。注意这个读取操作会改变光标位置。

a.readline(): 读入一行字符。会改变光标位置。

a.readlines(x): 读入x行字符，返回一个列表。a.readlines()默认返回全部的行。会改变光标位置。

for x in a:: 枚举文件的每一行(也取决于指针)。会改变光标位置。

a.write(x): 写入x。返回写入长度。

a.flush(): 清空缓冲区立即发生写入操作。

a.tell(): 返回光标位置(文件开始到光标的字符数目)。

a.seek(d,x): 使得光标的绝对位置变为t+d，其中d可正可负，x = 1表示t为当前位置，x = 0表示t = 0，x = 2表示t在文件末尾。

a.close(): 关闭文件。


数据类型

  • 新建变量: 直接对变量进行赋值。如a = 3，如果以前没有变量a，就新建了一个变量a。

  • 使用类型+()可以实现强制转换类型。使用type()函数可以获得一个变量的类型。

iter迭代器类型

Python迭代器只能每次向前，不能停留或倒退。

iter(a): 以一个可迭代对象开头地址生成一个迭代器。

next(it): 等价于C++中的*it++，迭代器自增，并返回目标值。

str字符串类型

str + str: 字符串拼接；str * int: 字符串复制。+=，*=同理。注意str类型不支持单点修改。

单引号'str'和双引号"str"是等价的，但不同之处在于: ''中出现单引号需要转义\'，却可以直接使用"；""中出现双引号需要转义\"，却可以直接使用'。

三引号'''str'''或"""str"""等价。可以直接通过回车键而不是\n换行。直接调用print()也可以起到换行效果，因为print()默认会在结尾输出一个回车，除非改变其end参数。

转义符号同C++。在末尾使用\可以使代码换行而输出结果不换行，也与C++相同。在字符串前加字母r可以阻止字符串转义(称为原生字符串)。如print(r'\n')就会输出\n。但是\"是有意义的，用于判断字符串是否结束，如字符串print(r"aaaa\"bbbb")就会输出aaaa\"bbbb，不过这也意味着原生字符串不可能以\字符结尾或是包含一个单独的"(除非用'字符串，反之亦然)。

a.count(x,l,r): 统计字符串中x出现的次数。可以选择开始和结束的下标[l,r)。

a.split(x,y): 将字符串按照x出现位置分割(去掉x)，只分割前y个出现的x，返回一个包含至多y+1个子字符串的列表。默认为y = -1，即a.split(x)分割所有的x。而a.split()默认按照空格分割。

x.join([]): 则会将列表中的元素以x为分隔符串联成一个字符串返回。因此可以用用''.join(a)将一个字符列表转为字符串。

a.startswith(x): 用于判断a的前缀是否是x。返回一个bool。

a.endswith(x): 用于判断a的后缀是否是x。返回一个bool。

x in a: 搜索字符串a中的片段x，返回一个bool值。

a.index(x): 搜索字符串a返回第一个片段x的位置。列表中必须包含x。

a.strip(x): 删除a和x的最长公共后缀。a.strip()默认去除行末不可见字符。

a.lower(): 返回a中字母转化为全小写字母的字符串。

a.upper(): 返回a中字母转化为全大写字母的字符串。

a.replace(x,y,t): 返回将a中的前t个x子串替换为y子串(如果不指定t则默认全部替换)的字符串。不会重复替换，不会覆盖替换。


格式字符串: %[(name)][flags][width].[precision]typecode

(name): 用于指定格式字符串和目标对象的对应关系。

flags: +表示右对齐正数加正号，-表示左对齐，表示右对齐加空格，0表示右对齐补0。

typecode: i表示整数，f/F表示小数，c表示字符(unicode而不仅仅是ASCII)，s表示字符串，o表示八进制整数，d表示十进制整数，x表示十六进制整数，e或E表示科学计数法，g和G表示自动科学计数法(超过六位数则使用科学计数法)。

在普通字符串中可以直接使用%，但是如果已经存在格式化字符串，再要打印%时就需要用%%表示百分号。

多个格式字符串可以用元组或字典表示。元组可以直接使用(a,b)，而字典需要指定对应关系{'name1':a,'name2':b}。

示例:

1
2
3
4
5
6
a = 12345
b = 99.99
c = -1234
d = 1234567891011121314151617181920
e = "abc"
print("%(a)+9i\n%(b)09.4f\n%(c)-8x\n%(d) 15.4e\n%(e)s\n"%{'a':a,'b':b,'c':c,'d':d,'e':e})

输出结果:

1
2
3
4
5
   +12345
0099.9900
-4d2    
     1.2346e+30
abc

在使用%f输出时小数会四舍五入，但在用%i输出时会截断:

1
2
3
a = 99.9999999
print("%f"%a)
print("%i"%a)

输出结果是:

1
2
100.000000
99

另一种方法是用format()函数，此时格式化字符串: x:[[fill]align][sign][#][0][width][,][.precision][typecode]

x: 当前字符串是format传入参数/元组/字典中下标为x的对象。

fill: 为用于填充的字符。

align: 表示对齐。<左对齐，>右对齐，=右对齐但是顺序为符号+填充+数字，^居中。

sign: +正数加正号，-正数不加，正数加空格。

#: 加上以后同时输出二进制、八进制、十六进制。

,: 加上以后添加三位数字分隔符。

typecode: 与普通格式化方法几乎相同，但是没有i。而typecode为%表示输出百分比。

例如之前的程序可以改为:

1
2
3
4
5
6
a = 12345
b = 99.99
c = -1234
d = 1234567891011121314151617181920
e = "abc"
print("{0:>+9d}\n{1:>09.4f}\n{2:<8x}\n{3: >15.4e}\n{4:s}\n".format(a,b,c,d,e))

输出结果是相同的。很明显，format()功能更丰富，也更加清晰易于理解。format字符串中需要用两个大括号一个大括号。更多format()格式化示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
tp1 = "i am {}, age {}, {}".format("seven", 18, 'alex')
tp2 = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
tp3 = "i am {0}, age {1}, really {0}".format("seven", 18)
tp4 = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tp5 = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tp6 = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tp7 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tp8 = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tp9 = "i am {:s}, age {:d}".format(*["seven", 18])
tp10 = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tp11 = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
print(tp1)
print(tp2)
print(tp3)
print(tp4)
print(tp5)
print(tp6)
print(tp7)
print(tp8)
print(tp9)
print(tp10)
print(tp11)

(在列表前加*可以将列表拆为若干独立参数，在字典前加**可以将字典的拆为若干独立参数key = value)输出结果:

1
2
3
4
5
6
7
8
9
10
11
i am seven, age 18, alex
i am seven, age 18, alex
i am seven, age 18, really seven
i am seven, age 18, really seven
i am seven, age 18, really seven
i am seven, age 18, really seven
i am 1, age 2, really 3
i am seven, age 18, money 88888.100000
i am seven, age 18
i am seven, age 18
i am seven, age 18

int整数类型，float小数类型，complex复数类型和bool布尔类型

+，-，*正常。/表示精确除法。**表示次方。//表示整除。%表示取余。这些操作参数都任意: 可以是整数或小数。对于小数整除的结果是除法结果下取整(最大的不大于答案的整数，负数也满足)。对于小数取余a%b会不断减去(或者对于负数来说加上)模数b的整数倍，最后得到一个[0,b)之间的小数。

Python中的float类型容易出现比较大的误差。


=，+=，-=正常。

<，>，==，<=，>=，!=正常。Python支持不等号的串联: a < b < c < d是一个合法的表达式。串联表达式只检查相邻关系:

3 < 5 == 5 != 6 >= 2这样的表达式也是合法的，而且为真。

and，or，not正常。


complex类型用j表示虚部。如a = 3 + 4j。

list列表类型和tuple元组类型

a = []: 创建空列表。

列表中包含的元素可以使任意类型，同一列表中的元素类型也可以不同。当然，列表的元素也可以是列表。

使用a[x]进行索引和修改，这和C++的数组一致。使用a[l:r]可以获得一个子列表包含a中[l,r)的元素。可以省略l或r甚至两个都省略，表示一直延伸到两端。注意这是一个拷贝，所以a和a[:]并不相同。

len(a): 返回列表大小。

a.count(x): 统计x的个数。

a.append(x): 追加单个元素。

a.extend([x]): 追加列表。

a.insert(i,x): 插入单个元素在列表的i位置。

a.remove(x): 删除列表中第一个x。列表中必须包含x。

a.del(i): 删除列表位置i的元素。

del a[l:r]: 删除列表[l,r)内的元素。

a.pop(i): 删除列表位置i的元素(a.pop()默认为最后一个元素)并作为返回值。

x in a: 搜索列表a中的元素x，返回一个bool值。

a.index(x): 搜索列表a返回第一个元素x的位置。列表中必须包含x。

a.sort(): 排序列表。

sorted(a): 返回一个排序过的列表。

a.reverse(): 翻转列表。


range(l,r,s)表示从l开始，步长为s，到r结束(注意不包含r)的一个列表。即类似于C++中的for(i = l; i < r; i += s)所访问到的i的集合。

range(l,r)表示range(l,r,1)；range(r)表示range(0,r,1)；range(r,l,-s)可以反向循环(这时候包括r不包括l)。

Python 3中range()是一个不同于普通列表的类型。print(range(2,5))不会输出[2, 3, 4]而会输出range(2,5)。但是for循环访问range和访问普通列表没有区别。


列表推导:

1
a = [FUNCTION(DATA) for DATA in b]

将b列表中的每个元素用FUNCTION()函数处理，返回值形成列表a。


元组是不可改变的列表，用()而不是[]表示。a = ()创建一个空的元组。

set集合类型

与C++的set类似。a = set()创建一个空的集合。或者a = {x}初始化一个集合，包含一个元素x。

a.add(x): 插入一个元素。如果已存在则不操作。

a.update(x): 插入一个元素，可以是列表/元组/字典。还可以用[x,y]批量添加区间内的所有正整数。

a.remove(x): 删除x。列表中必须包含x。

a.discard(x): 删除x。列表中必须包含x。

a.pop(): 脚本模式随机删除一个元素；交互模式删除排序后集合第一个元素。

a.clear(): 清空集合。

x in a: 搜索集合a中的元素x，返回一个bool值。

a.copy(): 返回一个集合副本。

a.difference(b): 求a和b的差集(包含在a却不包含在b的元素集合)。

a.difference_update(b): 求a和b的差集并赋值给a。

a.intersection(b): 求a和b的交集。

a.intersection_update(b): 求a和b的交集并赋值给a。

a.symmetric_difference(b): 求a和b的对称差(只在一个集合中出现的元素集合)。

a.symmetric_difference_update(b): 求a和b的对称差并赋值给a。

a.union(b): 求a和b的并集。

a.isdisjoint(b): 判断a和b是否无交。

a.issubset(b): 判断a是不是b的子集。

a.issuperset(b): 判断a是不是b的超集。

dict字典类型

与C++的map类似。a = {}创建一个空的字典。或者a = {x:y}初始化一个字典，包含一个x到y的映射。

a[x] = y: 添加映射。

a.keys(): 返回所有键构成的无序列表。

a.values(): 返回所有值构成的无序列表。

del a[x]: 删除映射。

a.clear(): 清空映射。

x in a: 搜索字典a中的键x，返回一个bool值。

NoneType空类型

例如无返回值函数或直接返回return后面没有东西的函数的返回值类型。输出一个NoneType的值会得到None。


结构语法

判断语句

1
2
3
4
5
6
if EXPRESSION:
  OPERATION
elif EXPRESSION:
  OPERATION
else:
  OPERATION

注意冒号。

循环语句

1
2
for i in [1,2,3,4,5]:
    OPERATION

(注意这里的i的值是列表中的元素而非列表下标)，或

1
2
for i in range(l,r,s):
    OPERATION

(这样得到一个区间的元素)，甚至

1
2
for i in STR:
    OPERATION

(此时i会依次枚举字符串中的每个字符)


1
2
while EXPRESSION:
    OPERATION

while循环。

同时，和C++一样，for循环和while循环可以使用continue和break。

函数

1
2
3
def FUNCTION(ARGUMENTS):
    OPERATION
    return SOMETHING

def后面的代码块都不是主程序的一部分。可以省略return SOMETHING或只省略SOMETHING。ARGUMENTS可以设置默认值。注意:

1
2
3
4
5
def f():
    a = 3
a = 5
f()
print(a)

程序会输出5而不是3。这是因为f()中的a是在f内重新建立的一个局部变量，而不是那个全局变量a。可以通过global关键字来改变这件事:

1
2
3
4
5
6
def f():
    global a
    a = 3
a = 5
f()
print(a)

如果一个global和参数重名，那么就会发生错误。例如下面的代码就是错误的:

1
2
3
4
5
6
def f(a):
    global a
    a = 3
a = 5
f(a)
print(a)

对于参数，如果传入的是数值、字符、元组等不可变类型，那么就是传值:

1
2
3
4
5
def f(b):
    b = 3
a = 5
f(a)
print(a)

这样输出的a就是5而不是3。但是如果传入的是可变类型，如列表、字典，那么就是引用(这与C++传数组相似):

1
2
3
4
5
def f(b):
    b[0] = 3
a = [5]
f(a)
print(a[0])

这样输出的a[0]就是3。当局部变量和传值参数重名时就会新建立一个局部变量，而当局部变量和引用参数重名时就会沿用引用变量。因此要尽量避免全局变量、参数和局部变量重名。

对于尚未编写的函数，可以使用pass关键字:

1
2
3
4
def F():
    pass
a = 3
print(a)

如果去掉pass那一行，则解释时会报错。

类

1
2
3
4
class CLASS:
    def FUNCTION(ARGUMENTS):
        OPERATION
        return SOMETHING

就可以定义一个class。a = CLASS()即可创建一个该类的对象。

同一个类的对象可以有不同的、任意的属性，无需在类中定义，例如:

1
2
3
4
5
6
class A:
    def F():
        return
a = A()
a.whatever = 3
print(a.whatever)

程序可以正常输出3。一个class的初始化函数名为__init__()，当类中声明了这样一个函数之后，每个新建的对象都经过了初始化(那么在__init__()中创建的属性就会是每个新对象共有的):

1
2
3
4
5
class A:
    def __init__(self, x):
        self.whatever = x
a = A(3)
print(a.whatever)

这样就输出3。对于一个class内部定义的函数，如果这个函数有传参，第一个参数就是变量自身，约定俗成用self表示，剩余的参数在创建时传入。不过，还有一种调用函数的方式:

1
2
3
4
5
6
7
8
class A:
    def __init__(self, x):
        self.whatever = x
    def F(self):
        self.whatever += 3
a = A(3)
A.F(a) # <==> a.F()
print(a.whatever)

就会输出6。这里调用函数A.F(a)与调用函数a.F()效果是相同的。

对于这样一个新定义的类，无法print，重载print的方法是定义__str__()函数(即转化为一个字符串的函数)。例如:

1
2
3
4
5
6
7
class A:
    def __init__(self, x):
        self.whatever = x
    def __str__(self):
        return "whatever = " + str(self.whatever)
a = A(3)
print(a)

会得到输出whatever = 3。

任意一个创建出来的类和实例对象都含有一个隐藏的__dict__字典，存储了它的属性。而对于一个实例，如果其尚未编辑某个属性，就会直接引向类的__dict__，否则就会使用自己的__dict__。因此会有如下事情发生:

1
2
3
4
5
class A:
    whatever = 1
a = A()
A.whatever = 2
print(a.whatever)

输出结果是2。但是如果在A.whatever = 2之前加上一句a.whatever = 1，输出结果就是1了。

类的继承:

1
2
3
4
5
6
7
8
9
10
11
12
13
class A:
    def __init__(self, x):
        self.whatever = x
    def __str__(self):
        return "whatever = " + str(self.whatever)
class B(A):
    def __init__(self, x):
        A.__init__(self, x)
        self.whateverelse = x+1
    def __str__(self):
        return A.__str__(self) + "\n" + "whateverelse = " + str(self.whateverelse)
b = B(3)
print(b)

会得到输出

1
2
whatever = 3
whateverelse = 4

生成器

1
2
3
4
5
6
7
8
def f():
    a = 0
    while True:
        yield a
        a += 1
g = f()
for i in range(10):
    print(next(g))

当一个函数含有yield关键字时就会被解读为一个生成器。将函数f()赋值给一个新建变量后就得到一个generator类型的变量g。此后每次调用next(g)就会生成一个新对象。上例就生成了一个0 ~ 9的数列。可以视作g保留了函数f()进行到某一阶段的状态，最初函数没有执行。此后每次调用next(g)就是继续执行函数直到一个断点yield，然后返回端点处的函数值。

例如一个生成斐波那契数列的生成器:

1
2
3
4
5
6
7
8
9
10
11
12
def f():
    a = 0
    b = 1
    c = 1
    while True:
        yield a
        a = b
        b = c
        c = a+b
g = f()
for i in range(10):
    print(next(g))

每次调用next(g)就得到下一个斐波那契数。如果函数f()执行完了(本例中因为while True所以不会发生)，就会返回异常。

yield函数也是有返回值的。可以用send(i)将i作为yield的返回值并调用一次next()。

例如求输入过的所有数字的和:

1
2
3
4
5
6
7
8
9
10
11
def S():
    s = 0
    t = 0
    while True:
        t = yield s
        s += t
g = S()
next(g)
while True:
    x = int(input())
    print(g.send(x))

异常处理

try-except语句:

1
2
3
4
5
6
7
8
try:
    OPERATION1
except ERRORS as e:
    OPERATION2
else:
    OPERATION3
finally:
    OPERATION4

即如果OPERATION1中发生了ERRORS类的错误(错误种类可以由错误或异常反馈得到，默认不写ERRORS as e就处理任何错误，不写as e可以不接受数据)，那么就创造一个对象e，并运行OPERATION2。对于多个不同的异常，可以合并在某个ERRORS中处理也可以分写多个except。e.message是一条错误信息字符串。如果OPERATION1没有错误就直接执行OPERATION3。而OPERATION4无论发生什么都会在程序退出之前正常执行。

raise ERROR可以强行引发一个异常。


with语句(以处理文件为例):

1
2
with open(PATH) as FILE:
    OPERATION

紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给FILE。当OPERATION全部被执行完之后，将调用前面返回对象的__exit__()方法。如果__enter__()或OPERATION出现异常，__exit__()也会被立即执行。


附: 标准异常表:

异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
SystemExit Python 解释器请求退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
KeyboardInterrupt 用户中断执行(通常是输入^C)
LookupError 无效数据查询的基类
IndexError 序列中没有没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告

模块

  • import: 引入头文件，Python中称为模块(module)。

    一个.py文件本身就可以作为一个模块，其中定义了许多函数和类。

    调用函数的时候使用module.function()调用这个模块中的函数，正如C++中的module::function()。

    from module import function就可以只引入module中的某一个function，在使用的时候可以直接调用function()。或者from module import *引入module中的全部函数和类，在使用的时候也可以直接调用。但是需要注意重名。还可以用import module as A来简化一个命名空间。

BIF

abs(x): 返回∣x∣\lvert x \rvert。

sum(a,t): 返回对a中元素求和再加t的值。

ord(x): x的ASCII码。

chr(x): ASCII码为x的对应字符。

min(x,y)/max(x,y): 最小值，最大值。

isinstance(a,type): a是不是一个type类型的对象。

len(a): 返回列表的长度。

id(x): 返回对象x的内存地址。

a is b: 判断a是否是b(相同的内存地址、类型、值)。注意Python中不同时间声明的两个量可能共用内存地址:

1
2
3
a = "abcdefg"
b = "abcdefg"
print(a is b)

输出结果是true。检查可以发现两者确实具有相同的id。

sorted(a): 返回一个有序的列表/字典。无论是.sort()还是sorted()都支持传入比较函数，常用λ\lambda表达式，例如:

1
2
a = [(1,2,3),(3,2,1),(3,1,2),(2,3,1)]
print(sorted(a,key=lambda x: x[2]))

就会按照最后一项排序得到[(3, 2, 1), (2, 3, 1), (3, 1, 2), (1, 2, 3)]。

enumerate(a,s): 将列表a中的项a[i]和数字s+i构成一个二元组返回成一个列表，可以用list强转为普通列表。也可以用二元组直接访问。默认从s = 0开始。例:

1
2
for i,j in enumerate(a):
    OPERATION

这时候i就是元素，j就是这个元素的标号。

map(F,a): 给定序列a = [a0,a1,a2,...]返回构造序列[F(a0),F(a1),F(a2),...]。以及λ\lambda表达式，使用范例:

1
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

得到输出[3, 7, 11, 15, 19]。

string

letters: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

lowercase: 'abcdefghijklmnopqrstuvwxyz'

uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

octdigits: '01234567'

digits: '0123456789'

hexdigits: '0123456789abcdefABCDEF'

punctuation: 

1
2
3
4
5
6
7
8
9
10
11
12

### collections

`Iterable`: 可以被迭代的对象类型。使用方法如: `isinstance(a,Iterable)`判断一个对象是否可以被迭代。

`namedtuple`: 定义一个有名字的元组，例如定义元组`A`以后`A`就可以作为一个类型使用:

```python
from collections import *
A = namedtuple('A',['a','b','c'])
a = A(1,2,3)
print("{} {} {}".format(a.a,a.b,a.c))

就会正确输出1 2 3。也就是现在元组有了名字A，元组每个元素也有了名字a，b和c。

deque: 双端队列，支持列表的append()，appendleft()，pop()和popleft()。

sys

exit(x): 退出Python。返回x。

getsizeof(x): 以字节byte为单位返回对象大小。

stdin/stdout/stderr: 标准输入/输出/错误流。可以直接用文件方式操作，如:

1
2
3
import sys
sys.stdout.write(SOMETHING)
sys.stdout.flush()

math

e: 自然常数。

pi: 圆周率。

floor(x): 返回小于等于x的最大整数。

ceil(x): 返回大于等于x的最小整数。

trunc(x): 返回x的整数部分。

copysign(x,y): 返回x的符号变为y的符号后的值。

sqrt(x): 返回x\sqrt x。

cos(x)/sin(x)/tan(x): 弧度制三角函数。

degrees(x)/radians(x): 弧度转角度/角度转弧度。

exp(x): 返回exe^x。

expm1(x): 返回ex−1e^{x-1}。

fabs(x): 返回∣x∣\lvert x \rvert。

factorial(x): 返回x!x!，xx必须是非负整数。

fsum(a): 返回对a中元素求和的值。

gcd(x,y): 返回最大公因数。注意并不存在最小公倍数函数。

hypot(x,y): 返回x2+y2\sqrt{x^2+y^2}。

isfinit(x)/isinf(x): 判断x是否有限。

log(x,b)/log2(x)/log10(x): 返回log⁡bx\log_b^x。log(x)默认返回ln⁡x\ln x。

time

time(): 返回1970年1月1日午夜到现在经过的秒数(精确到ms的小数)。

localtime(time()): 得到一个struct_time9元组表示时间: 年-月-日-时-分-秒-一周第几日-一年第几日-夏令时

asctime(localtime(time())): 得到一个时间字符串，例如Thu Jul 11 18:16:47 2019。

strftime("",localtime(time())): 得到一个任意格式时间字符串，前面的字符串中用%+Y/m/d/H/M/S/…表示。

clock(): 返回当前CPU时间。常用于计算时间差。

sleep(x): 程序推迟x秒。

random

randrange(l,r,s): 均匀概率返回一个[l,r)内步长为s的集合内的整数。

randint(l,r): 均匀概率返回一个[l,r]内的整数。可以说randint(l,r) = randrange(l,r+1)。

random(): 均匀概率返回一个[0,1)内的小数。

choice(a): 在列表a中均匀概率返回一个元素。

sample(a,x): 在列表中均匀随机选取x个不同下标的元素。x必须不超过a的长度。

os

  • 关于路径

    绝对路径示例: "C:/Program Files (x86)/Internet Explorer"或"C:\\Program Files (x86)\\Internet Explorer"

    相对路径示例: ./Files当前目录下的文件夹；../Files上一层目录下的文件夹；/Files项目根目录的文件夹。

listdir(path): 返回一个列表包含path下的目录和文件。

getcwd(): 返回当前工作目录绝对路径字符串。

chdir(path): 将工作目录改变到path。

path.exists(path): 判断是否存在path，无论是文件还是目录。

path.isdir(path): 判断是不是一个目录。文件或不存在返回False。

path.isfile(path): 判断是不是一个文件。非文件或不存在返回False。

path.getsize(path): 返回文件大小。目录大小为0。

path.abspath(path): 转为绝对路径。

path.normpath(path): 返回规范化字符串。(将路径的/转化为\\)

path.split(path): 分离路径与最后一个文件/目录名。

path.splitext(path): 分离路径与最后一个文件的后缀名。目录后缀名为空。

pickle

dump(x,file): 将x保存在文件file中。

load(file): 返回之前保存过的x。


扫描二维码即可在手机上查看这篇文章，或者转发二维码来分享这篇文章:


文章作者: Magolor
文章链接: https://magolor.cn/2019/07/14/2019-07-14-blog-01/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Magolor！
OI资源Python
扫描二维码在手机上查看或转发二维码以分享Magolor的博客