Python基础

python官网：http://www.python.org

python官方文档：https://docs.python.org/2/  or  https://docs.python.org/3/

python第三方插件：https://pypi.python.org/pypi

Ubuntu下python的第三方插件包的默认路径：/usr/local/lib/python2.7/dist-packages/

 

1.交互模式（python编译器python.exe）下，符号“_”是特殊标识符，保留了表达式的最后一个计算结果。

  如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

 

2.标识符

  （1）有字母、数字和下划线组成，但不能以数字开头；

  （2）区分大小写；

  （3）以单下划线开头（如：_foo）的，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能“from xxx import * ”导入；

  （4）以双下划线开头（如：__foo）的，表示类的私有成员；

  （5）以双下划线开头和结尾的（如：__init__），代表特殊方法专用的标识；

 

3.多行语句

  （1）可用“\”将一行的语句氛围多行显示，如：      

total = item_one + \ 
        item_two + \
        item_three

 

  （2）若语句中包含[]，{}，()就不需要使用多行连接符，如：

 days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

 

 

 

4.注释

  （1）用“#”开头，python没有块注释；

 

5.同一行显示多条语句：用“;”分隔；

 

6.多个变量赋值

 

Python允许你同时为多个变量赋值。如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。如：

a, b, c = 1, 2, "john"

以上实例，两个整型对象1和2的分配给变量a和b，字符串对象"john"分配给变量c。

 

7.数字

  （1）不可改变；

  （2）删除可用del语句；

  （3）支持复数形式；

 

8.字符串

  （1）打印字符串，既可以用双引号，也可用单引号；

  （2）字符串中有特殊字符，如“\n”需要打印的，只需在字符串引号前加“r”；

           如：

>>> print r'C:\some\name'  # note the r before the quote
C:\some\name

  （3）字符串连接，除了“+”，还可以单独字符串并排；

           如：

>>> 'Py' 'thon'
'Python'

  （4）打印字符串中，有的特殊符号，可用反斜杠进行转义；

  （5）打印多行，需用 """或 '''；

          注：在第一个3引号后加“\”，可略去开头的空行；

          如：

print """
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
"""

produces the following output (note that the initial newline is not included):

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

 

print """\ Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """

produces the following output (note that the initial newline is not included):

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

  （6）字符串可用“+”和“*”连接；

          如：

>>> 3 * 'un' + 'ium'
'unununium'

  （7）两个或多个字符串写在一起，会一起打印出来；

           如：

>>> 'Py' 'thon'
'Python'

         注：必须是字符串，若要变量或表达式连一起打印，用“+”；

  （8）字符串索引可用负数表示，表示从右边开始；

           如：

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

           注：因为-0等于0，因此负数是从-1开始的；

  （9）word=“Python”

          word[0:2]表示“Py”；#表示从位置0开始到位置2

          word[:2]表示“Py”；

          word[4:]表示“on”；

          word[42]会报错，但是：

>>> word[4:42]
'on'
>>> word[42:]
''

  （10）字符串不能改变其值，如word[0]=‘J’会报错；

  （11）startswith()函数：判断字符串是否以指定字符或子字符串开头

          语法：string.startswith(str, beg=0,end=len(string))
                   或string[beg:end].startswith(str)
 
          参数说明：
          string：  被检测的字符串
          str：      指定的字符或者子字符串。（可以使用元组，会逐一匹配）
          beg：    设置字符串检测的起始位置（可选）
          end：    设置字符串检测的结束位置（可选）
          如果存在参数 beg 和 end，则在指定范围内检查，否则在整个字符串中检查

          返回值
          如果检测到字符串，则返回True，否则返回False。默认空字符为True

          函数解析：如果字符串string是以str开始，则返回True，否则返回False

  （12）转义字符

 

转义字符	描述
\（在行尾）	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格（backspace）
\e	转义
\000	空
\n	换行
\v	纵向制符表
\t	横向制符表
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，如：\o12代表换行
\xyy	十六进制数，yy代表的字符，如：\x0a代表换行
\other	其它的字符以普通格式输出

 

  （12）运算符

            a="Hello"，b="Python"

 

操作符	描述
+	字符串连接，如：a+b输出“HelloPython”
*	重复输出字符串，如：a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符，如：a[1] 输出结果 e
[ : ]	截取字符串中的一部分，如：a[1:4] 输出结果 ell
in	成员运算符，如果字符串中包含给定的字符返回True，如：H in a 输出结果 1
not in	成员运算符，如果字符串中不包含给定的字符返回True，如：M not in a 输出结果 1
r/R	原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符
%	格式字符串

 

  （13）格式化符号

 

 

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号号十六进制数
%X	格式化无符号号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e
%g	%f和%e的简写
%G	%f和%E的简写
%p	用十六进制数格式化变量的地址

 

  （14）三引号：可以将复杂的字符串进行复制，允许一个字符串跨多行；

 

  （15）Unicode字符串：引号前加小写的"u"；

  （16）连接字符串，用join和用+的区别：字符串是不可变对象，当用操作符+连接字符串的时候，每执行一次+都会申请一块新的内存，然后复制上一个+操作的结果和本次操作的右操作符到这块内存空间，因此用+连接字符串的时候会涉及好几次内存申请和复制。而join在连接字符串的时候，会先计算需要多大的内存存放结果，然后一次性申请所需内存并将字符串复制过去，这是为什么join的性能优于+的原因。所以在连接字符串数组的时候，我们应考虑优先使用join；join 是首先遍历 list 中的每一个字符串确定 maxchar 通过 maxchar 和所有字符串的长度和 sz 通过 PyUnicode(sz,maxchar) 创建新的字符串对象 然后通过每一个字符串的长度和偏移将 list 字符串快速拷贝到新串中

（17）连接字符串format和join的区别：format 其实是先通过 FORMAT_VALUE 将其他类型转换为 str 类型并且把 str 压入栈。然后进行 join；join 和 format 两个都落实到 _PyUnicode_JoinArray()这个函数上去了，比如 f"{100},200,{300}"等同与''.join(['100',',200,','300'])  说到效率问题因为 join 只能连接字符串而且 FORMAT_VALUE 这个字节码他的具体计算会落实到 Python 实现所以转化的效率不高。
也就是说 join 和 format 的效率区别在于 format 需要将其他类型转化成为 str 而且这个转化过程还是 Python 实现的而 join 只针对与 str

 

9.Lists

  （1）用方括号[]囊括，不需要具有相同的类型；

  （2）下标使用跟string类型一样；

  （3）可以修改数列的值；

          如：

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

          另一个：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

  （4）数列也可嵌套使用；

           如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

 

10.元组

  （1）类似于列表，用圆括号()标识，内部元素用逗号隔开；

  （2）元素不能赋值和修改，相当于只读列表；

  （3）空元组：tup1=()；

  （4）元组中若只包含一个元素时，需在元素后添加逗号：tup1 = (50, )；

  （5）修改元组：元组中的元素不允许修改，但可对元组进行连接组合；

  （6）删除元组：只能用del删除整个元组；

  （7）任意无符号的对象，以逗号隔开，默认为元组；

 

11.字典

  （1）可存储任意类型的对象；

  （2）由“键+值”组成，中间用冒号隔开；

  （3）每对用逗号分隔，整体放在花括号（{}）中；

  （4）键必须唯一，值则不必，可取任何数据类型，但是必须不可变；

  （5）创建时如果同一个键被赋值两次，后一个值会被记住；

 

11.数据类型转换

 

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base])	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象x转换为字符串
repr(x)	将对象x转换为表达式字符串
eval(str)	用来计算在字符串中的有效python表达式，并返回一个对象
tuple(s)	将序列s转换为一个元祖
list(s)	将序列s转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典，d必须为一个序列（key,value）元祖
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

 

12.运算符优先级

 

 

运算符	描述
**	指数（最高优先级）
~ + -	按位翻转，一元加号和减号（最后两个的方法名为+@和-@）
* / % //	乘，除，取模和取整数
+ -	加法减法
>> <<	右移，左移运算符
&	位'AND'
^ |	位运算符
<= < > >=	比较运算符
< > == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

 

13.if...elif...else

 

14.continue语句是跳出本次循环，而break是跳出整个循环

 

15.函数

  （1）以def关键词开头；

  （2）函数内容以冒号起始，并且缩进；

  （3）Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None；

  （4）Lambda函数创建小型匿名函数，这种函数得名于省略了用def声明函数的标准步骤；

  （5）return语句；

  （6）设置函数默认值：在函数的定义中，最后定义参数的默认值；

 

16.命名空间和作用域

  （1）一个python表达式可以访问局部命名空间和全局命名空间里的变量；

  （2）若一个局部变量和一个全局变量重名，则全局变量会覆盖局部变量；

  （3）Python会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的；

 

17. import / from...import / from...import* 语句

  （1）想使用Python源文件，只需在另一个源文件里执行import语句；

  （2）Python的from语句让你从模块中导入一个指定的部分到当前命名空间中;

  （3）from...import*语句会把一个模块的所有内容全都导入到当前的命名空间；

  （4）为了告诉python想要将目录下的一个文件夹当做包一样使用，需要增加一个文件：__init__.py，一般为空；

 新文件结构可能如下：

           Myproject/

             - main.py

             - classes/

                 - __init__.py

                - monsters.py

        导入模块语句：from classes.monsters import Monster

  （5）import module：调用的时候应该使用“module.方法”；

  （6）把模块导入到shell中，如导入random，输入help(random)将会显示random模块的文档；

 

18.文件I/O

  （1）键盘输入：input()函数用于收集信息（用户的输入自动匹配正确的数据类型），而raw_input()函数用于收集任何非数字信息（用户的输入保存为字符串）；

                         raw_input([prompt])函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）；

                         input([prompt]) 函数和raw_input([prompt]) 函数基本可以互换，但是input会假设你的输入是一个有效的Python表达式，并返回运算结果。

  （2）格式化输入之一：format()函数；

  （3）打印提示语若为中文，在cmd窗口下，避免出现乱码应采取的措施：browser_url = raw_input("请输入浏览器地址：".decode('utf-8').encode('gbk'))

 

19.python的包，详见：https://docs.python.org/2/library/

 

20.模块的一个不完全列表：https://wiki.python.org/moin/UsefulModules

 

21.当前为python开发的所有第三方模块：https://pypi.python.org/pypi

 

22.类

  （1）类的定义中，__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法；

  （2）python内置类属性：

           ①__dict__：类的属性（包含一个字典，由类的数据属性组成）；

           ②__doc__：类的文档字符串；

           ③__name__：类名；

           ④__module__：类定义所在的模块；

           ⑤__bases__：类的所有父类构成元素；

 

23.类的继承

  （1）语法：class 派生类名（基类名）；

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

 

  （2）在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用；

  （3）在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量；

  （4）Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找；

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

 

24.正则表达式

  （1）re模块（需要import re）：re.match / serach (pattern, string, flags=0)；

         1） 函数参数说明：

 

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串
flags	标志位，用于控制正则表达式

         2）可用group(num)或groups()匹配对象函数获取匹配表达式；

 

               num=0，表示整个字符串；

               num>0，若之前有多个括号，即多个group，那么分别对应group(1),group(2)，。。。；

               groupsz()表示从group(1)开始往后的所有的值，组合成一个Tuple类型的值；

         3）re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配；

         4）re.sub用于替换字符串中的匹配项：re.sub(pattern, rep1, string, max=0)；

         5）修饰符：

 

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别匹配
re.M	多行匹配，影响^和$
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

 

  （2）模式：

 

 

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
[...]	用来表示一组字符,单独列出：[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	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\z	匹配字符串结束
\G	匹配最后匹配完成的位置
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'
\n, \t, 等.	匹配一个换行符，匹配一个制表符
\1...\9	比赛第n个分组的子表达式
\10	匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式

 

25.用docstring说明代码：可用三引号、单引号和双引号括起来，在shell中，若用内建的help()函数，可看到这些说明；

 

 

26.读

 

 

 不懂：

1.unicode编码

2.input([prompt]) 函数和raw_input([prompt]) 函数区别