python基础

.py base

CGI (Common Gateway Interface)
通用网关接口,它是一段程序,运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口

测试 import doctest import unittest

性能差异度量 from timeit import Timer
print(Timer('a,b = b,a', 'a=1; b=2').timeit()) //输出运行时间

数据压缩 import zlib //zlib、gzip、bz2、zipfile、tarfile
zlib.compress(s) //压缩
zlib.decompress(t) //压缩之后赋值给t，才能用扩展

时间日期 from datetime import date
date.today() //今天
date(1964, 7, 31) //

互联网
urls 接收的数据 from urllib.request import urlopen
邮件 import smtplib

随机 import random
random.choice(['1', '2', '3']) //列表中随机一个
random.sample(range(100), 3) //100 随机取3个
random.random() //0 - 1 之间16位小数
random.randrange(6) // 0 - 5 之间一个整数

数学 import math
math.cos(math.pi / 4) //0.70710678118654757
math.log(1024, 2) //10.0

正则 import re
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
re.match函数
从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none
re.match(pattern, string, flags=0)
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
re.search(pattern, string, flags=0) //扫描整个字符串并返回第一个成功的匹配
检索替换
re.sub(pattern, repl, string, max=0) //用于替换字符串中的匹配项
phone = "12-3-4 # 这是一个电话号码"
re.sub(r'#.*$', "", phone) //12-3-4
正则修饰符
re.I 使匹配对大小写不敏感
re.L 做本地化识别（locale-aware）匹配
re.M 多行匹配，影响 ^ 和 $
re.S 使 . 匹配包括换行在内的所有字符
re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
正则模式
[...] 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re* 匹配0个或多个的表达式。
re+ 匹配1个或多个的表达式。
re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}
re{ n,} 精确匹配n个前面表达式。
re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b 匹配a或b
(re) G匹配括号内的表达式，也表示一个组
(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re) 类似 (...), 但是不表示一个组
(?imx: re) 在括号中使用i, m, 或 x 可选标志
(?-imx: re) 在括号中不使用i, m, 或 x 可选标志
(?#...) 注释.
(?= re) 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re) 匹配的独立模式，省去回溯。
\w 匹配字母数字
\W 匹配非字母数字
\s 匹配任意空白字符，等价于 [\t\n\r\f].
\S 匹配任意非空字符
\d 匹配任意数字，等价于 [0-9].
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
\z 匹配字符串结束
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
\1...\9 匹配第n个分组的子表达式。
\10 匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。
正则实例
[Pp]ython 匹配 "Python" 或 "python"
rub[ye] 匹配 "ruby" 或 "rube"
[aeiou] 匹配中括号内的任意一个字母
[0-9] 匹配任何数字。类似于 [0123456789]
[a-z] 匹配任何小写字母
[A-Z] 匹配任何大写字母
[a-zA-Z0-9] 匹配任何字母及数字
[^aeiou] 除了aeiou字母以外的所有字符
[^0-9] 匹配除了数字外的字符
. 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'

sys.stderr.write('Warning,打印此句\n 换行')
脚本的定向终止都使用 "sys.exit()"

os 这样的大型模块时内置的 dir() 和 help() 函数
import os
dir(os)
help(os)
文件通配符
glob.glob('*.py') //于从目录通配符搜索中生成文件列表

面向对象
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

OS文件 / 目录方法
os.access(path, mode)
检验权限模式

os.chdir(path)
改变当前工作目录

os.chflags(path, flags)
设置路径的标记为数字标记。

os.chmod(path, mode)
更改权限

os.chown(path, uid, gid)
更改文件所有者

os.chroot(path)
改变当前进程的根目录

os.close(fd)
关闭文件描述符 fd

os.closerange(fd_low, fd_high)
关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略

os.dup(fd)
复制文件描述符 fd

os.dup2(fd, fd2)
将一个文件描述符 fd 复制到另一个 fd2

os.fchdir(fd)
通过文件描述符改变当前工作目录

os.fchmod(fd, mode)
改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。

os.fchown(fd, uid, gid)
修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。

os.fdatasync(fd)
强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。

os.fdopen(fd[, mode[, bufsize]])
通过文件描述符 fd 创建一个文件对象，并返回这个文件对象

os.fpathconf(fd, name)
返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。

os.fstat(fd)
返回文件描述符fd的状态，像stat()。

os.fstatvfs(fd)
返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()

os.fsync(fd)
强制将文件描述符为fd的文件写入硬盘。

os.ftruncate(fd, length)
裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。

os.getcwd()
返回当前工作目录

os.getcwdu()
返回一个当前工作目录的Unicode对象

os.isatty(fd)
如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。

os.lchflags(path, flags)
设置路径的标记为数字标记，类似 chflags()，但是没有软链接

os.lchmod(path, mode)
修改连接文件权限

os.lchown(path, uid, gid)
更改文件所有者，类似 chown，但是不追踪链接。

os.link(src, dst)
创建硬链接，名为参数 dst，指向参数 src

os.listdir(path)
返回path指定的文件夹包含的文件或文件夹的名字的列表。

os.lseek(fd, pos, how)
设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效

os.lstat(path)
像stat(),但是没有软链接

os.major(device)
从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。

os.makedev(major, minor)
以major和minor设备号组成一个原始设备号

os.makedirs(path[, mode])
递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。

os.minor(device)
从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。

os.mkdir(path[, mode])
以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。

os.mkfifo(path[, mode])
创建命名管道，mode 为数字，默认为 0666 (八进制)

os.mknod(filename[, mode=0600, device])
创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。

os.open(file, flags[, mode])
打开一个文件，并且设置需要的打开选项，mode参数是可选的

os.openpty()
打开一个新的伪终端对。返回 pty 和 tty的文件描述符。

os.pathconf(path, name)
返回相关文件的系统配置信息。

os.pipe()
创建一个管道. 返回一对文件描述符(r, w) 分别为读和写

os.popen(command[, mode[, bufsize]])
从一个 command 打开一个管道

os.read(fd, n)
从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。

os.readlink(path)
返回软链接所指向的文件

os.remove(path)
删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。

os.removedirs(path)
递归删除目录。

os.rename(src, dst)
重命名文件或目录，从 src 到 dst

os.renames(old, new)
递归地对目录进行更名，也可以对文件进行更名。

os.rmdir(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。

os.stat(path)
获取path指定的路径的信息，功能等同于C API中的stat()系统调用。

os.stat_float_times([newvalue])
决定stat_result是否以float对象显示时间戳

os.statvfs(path)
获取指定路径的文件系统统计信息

os.symlink(src, dst)
创建一个软链接

os.tcgetpgrp(fd)
返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组

os.tcsetpgrp(fd, pg)
设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。

os.tempnam([dir[, prefix]])
返回唯一的路径名用于创建临时文件。

os.tmpfile()
返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。

os.tmpnam()
为创建一个临时文件返回一个唯一的路径

os.ttyname(fd)
返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。

os.unlink(path)
删除文件路径

os.utime(path, times)
返回指定的path文件的访问和修改的时间。

os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
输出在文件夹中的文件名通过在树中游走，向上或者向下。

os.write(fd, str)
写入字符串到文件描述符 fd中. 返回实际写入的字符串长度

文件 File
file.close() 关闭文件。关闭后不能再操作
file.flush() 刷新缓冲，直接把内部缓冲区的数据立刻写入文件
file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
file.next() 返回文件下一行。
file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size])读取整行，包括 "\n" 字符。
file.readlines([sizehint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
file.seek(offset[, whence]) 设置文件当前位置
file.tell() 返回文件当前位置。
file.truncate([size]) 截取文件，截取的字节通过size指定，默认为当前文件位置。
file.write(str) 将字符串写入文件，没有返回值。
file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

str() 函数返回一个用户易读的表达形式。
repr() 产生一个解释器易读的表达形式。
s = 'ysx'
print(str(s)) //ysx
print(repr(s)) //'ysx'

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

遍历技巧
字典中遍历时，关键字和对应的值可以使用 items()方法同时解读出来
obj = {'a':'aa','b':'bb'}
for k,v in obj.items():
print(k,v) //a aa b bb
zip 同时遍历多个列表
ques = ['name', 'que1', 'color']
ans = ['ysx', 'answer1', 'blue']
for q,a in zip(ques,ans):
print('whart is your {0}? it is {1}'.format(q,a))
输出：
whart is your name? it is ysx
whart is your que1? it is answer1
whart is your color? it is blue
sorted() 按顺序遍历一个序列
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)): //去重排序
print(f)
for f in sorted(basket): //不去重排序
print(f)

列表可以修改，而字符串和元组不能
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[:]
列表推导论
vec = [2, 4, 6]
[[x, x**2] for x in vec] //[[2, 4], [4, 16], [6, 36]]
[3*x for x in vec if x > 3] //[12, 18]

函数
定义函数使用 def
def a_mean(*args):
sum = 0
for x in args:
sum += x
return sum

print(a_mean(1,2,3,4)) //10 1+2+3+4

生成器
yield 的函数被称为生成器（generator）

迭代 iter() 和 next()
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退
list = [1,2,3,4]
it = iter(list)
print(next(it)) //1
print(next(it)) //2
print(next(it)) //3
for x in it:
print(x) //1 2 3 4

循环
while
while condition:
statements
for
for <variable> in <sequence>
<statements>
else:
<statements>

languages = ["C", "C++", "Perl", "Python"]
for x in languages:
print x

for 中 break 跳出当前循环
（continue）跳过当前循环块中的剩余语句，继续进行下一轮循环！！
（理解为行级）

range()函数
for i in range(3):
print(i) //0 1 2 3
for i in range(3,5):
print(i) //3 4
指定数字开始 结束 增量
for i in range(3,10,2): //开始 结束 增量
print(i) //3 5 7 9
遍历序列的索引
a = ['a','b','c','d','e','f','g','h','i','j']
for i in range(len(a))
print(i,a[i])
0 a
1 b
2 c
3 d..........
创建列表
list(range(5))
[0, 1, 2, 3, 4]

条件
Python中没有switch – case //if elif else
if con1:
block_1
elif con2:
block_2
else:
block_3
运算符 同 js、java、
+ 加 - 两个对象相加 a + b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
< 小于
<= 小于或等于
> 大于
>= 大于或等于
== 等于，比较对象是否相等
!= 不等于
逻辑运算符 不同于(js java)//and or not
a 为 10, b为 20
x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
x or y 布尔"或" - 如果 x 是 True，它返回 x的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

in x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
字典（理解为java,js 对象）
键必唯一，但值不必
eg: dict = {key1 : value1, key2 : value2 }
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
取值
print(dict['key1']) //value1 //空键 报错
dict['key1'] = 8; //修改值
删除字典
del dict['key1'] # 删除键 'key1'
dict.clear() # 删除字典
del dict # 删除字典

字典内置函数
len(dict) //计算字典元素个数，即键的总数。
str(dict) //输出字典以可打印的字符串表示。

字典的内置方法
dict.clear()
删除字典内所有元素
dict.copy()
返回一个字典的浅复制
dict.fromkeys()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
key in dict
如果键在字典dict里返回true，否则返回false
dict.items()
以列表返回可遍历的(键, 值) 元组数组
dict.keys()
以列表返回一个字典所有的键
dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)
把字典dict2的键/值对更新到dict里
dict.values()
以列表返回字典中的所有值

元组与列表类似，不同之处在于元组的元素不能修改
元组使用小括号
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
以下修改元组元素操作是非法的。
tup1[0] = 100 //非法修改

tup3 = tup1 + tup2; //创建新元素，合法
del tup1; //删除整个元组
运算
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print x, 1 2 3 迭代

元组截取
tuple[2] //取索引为2的
tuple[-2] //取索引为-2的
tuple[1:] //取索引为1及之后的
元组的内置方法
len(tuple) 计算元组元素个数
max(tuple) 返回元组中元素最大值
min(tuple) 返回元组中元素最小值
tuple(seq) 将列表转换为元组

列表
x = [['a', 'b', 'c'], [1, 2, 3]]
x[0] //['a', 'b', 'c']
x[0][1] //'b'

del语句删除一些对象引用
del var1[,var2[,var3[....,varN]]]]
del var_a, var_b

Python支持四种不同的数值类型：
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）

字符串
s = 'ilovepython'
s[1:5]的结果是love

赋值
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
a = b = c = 1
a, b, c = 1, 2, "john"
数据类型
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）

语句结束以冒号 : 结尾

cmp(x,y) //比较两个值
len(seq) //返回序列的长度
list(sql) //序列转换为列表
max(sql) //最大
min(sql) //最小
reversed(sql) //对序列进行反向迭代
sorted(sql) //返回包含已排序的sql所有元素的列表
tupled(sql) //序列转换为元组

x=1,2,3,4
print(x[0:2]) //(1, 2)

tuple 转化为元组
tuple('abc') //('a','b','c')

元组 （数组的[]改为()就是元组）
元组不可修改，逗号隔开
(1,) //一个值得元组
3*(40+1,) //(41,41,41)

sort 排序
x = [1,2,3,4]
x.sort()

reverse 倒序数组
x.reverse()

remove 移出列表中某个元素
x = [1,2,3,4]
x.remove(3)
print(x) //[1, 2, 4]

pop 移出列表中一个元素 默认最后一个
x = [1,2,3,4]
x.pop() //[1,2,3]
x.pop(0) //[2,3,4]
print(x)

insert 将对象插入到列表
number = [1,2,3,4,5]
number.insert(3,'ffff') //[1,2,3,'ffff',4,5]

count 统计元素在列表中出现的次数
x=[[1,2],[1,2],1,2,2,3,4,5,6]
print(x.count([1,2])) // 1

extend 在列表末尾一次性追加另一个序列的多个值
a = [1,2,3]
b = [4,5,6]
a.extend(b) /等同于 a[len(a):] = b前者可读性更高 //[1,2,3,4,5,6]

分片赋值
number = [1,2,3,4,5,6]
number[1:1] = [a,b,c] //插入{也可替换}

append 尾部添加元素
number.append(7)

分片
number = [1,2,3,4,5,6]
number[:] //所有
print(number[3:4]) //从3开始，小于4 //[4]

转义 \\n
path = 'C:\\now' 等于 path = r'C:\now' //原始字符串

换行 \n
2/1 除
5%2 余
8//3 整除
* 乘 //print("phthon "*5)

 

www.python.org

PyCharm
http://www.jetbrains.com/pycharm/download/

下载jar包放在bin下
JetbrainsCrack-2.6.10-release-enc.jar

bin下两个文件添加
pycharm.exe.vmoptions
pycharm64.exe.vmoptions
-javaagent:D:\works\Python\PyCharm 2018.2\bin\JetbrainsCrack-2.6.10-release-enc.jar