1.Python基础语法

转自菜鸟教学：https://www.runoob.com/python

1.1 简单执行命令
print("Hello,Python!)"

1.2 脚本文件添加可执行权限

$chmod +x test.py    #脚本文件添加可执行权限 
$ ./test.py

1.3 标识符：
_foo代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from xxx import *而导入；
以双下划线开头的__foo代表类的私有成员；以双下划线开头结尾的__foo__代表Python里特殊方法专用的标识，如__init__()代表类的构造函数。

1.4 同一行显示多条语句，用分号；隔开，如：

>>> print ('hello');print('Python');

1.5 多行语句显示
Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠（ ）将一行的语句分为多行显示，如下所示：

total = item_one + \
        item_two + \
        item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：

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

1.6 Python引号
Python 可以使用引号( ‘ )、双引号( ” )、三引号( ”’ 或 “”” ) 来表示字符串，引号的开始与结束必须的相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

1.7 Python空行
函数之间或类的方法之间用空行分隔，标识一段新的代码开始。
类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行不会报错，但是程序代码的一部分。

1.8缩进报错提示：

IndentationError: unindent does not match any outer indentation level

错误表明，你使用的缩进方式不一致，有的是 tab 键缩进，有的是空格缩进，改为一致即可。

如果是 IndentationError: unexpected indent 错误, 则 python 编译器是在告诉你”Hi，老兄，你的文件里格式不对了，可能是tab和空格没对齐的问题”，所有 python 对格式要求非常严格。
因此，在 Python 的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用

2.Python变量类型

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
2.1变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print(counter)
print(miles)
print(name)

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

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：

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

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

2.3 标准数据类型
在内存中存储的数据可以有多种类型。
例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。
Python 定义了一些标准类型，用于存储各种类型的数据。
Python有五个标准的数据类型：

• Numbers(数字)
• String(字符串)
• List(列表)
• Tuple(元组)
• Dictionary(字典)

2.3.1 Python数字
数字数据类型用于存储数值。
他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时，Number对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象的引用。
del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象的引用。例如：

del var
del var_a, var_b

数学函数
1）随机数函数
choice(seq)
从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。seq -- 可以是一个列表，元组或字符串。

print("",random.choice(range(10,20)))
print("",random.choice([1,2,3,4,5,6,7,8,9]))
print("",random.choice('GOOD!'))
print("",random.choice(['WL','YL','LY','QD','MY','LV','JX','SY','Teacher']))
randrange ([start,] stop [,step]) 

从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1

random()
随机生成下一个实数，它在[0,1)范围内。

import random
 
print ("", random.randrange(1, 100, 2)) # 从 1-100 中选取一个奇数
print (" ", random.randrange(100))# 从 0-99 选取一个随机数

▲▲▲不会seed([x])
改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

import random

random.seed()
print ("使用默认种子生成随机数：", random.random())

random.seed(10)
print ("使用整数种子生成随机数：", random.random())

random.seed("hello",2)
print ("使用字符串种子生成随机数：", random.random())

结果：

使用默认种子生成随机数： 0.9186252047469824
使用整数种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722

shuffle(lst)
将序列的所有元素随机排序。

import random
 
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ",  list)
 
random.shuffle(list)
print ("随机排序列表 : ",  list)

uniform(x, y)

随机生成下一个实数，它在[x,y]范围内。

import random

print ("uniform(5, 10) 的随机浮点数 : ",  random.uniform(0, 27))

print ("uniform(7, 14) 的随机浮点数 : ",  random.uniform(27, 28))

2）三角函数
acos(x)
返回x的反余弦弧度值。
asin(x)
返回x的反正弦弧度值。
atan(x)
返回x的反正切弧度值。
atan2(y, x)
返回给定的 X 及 Y 坐标值的反正切值。
cos(x)
返回x的弧度的余弦值。
hypot(x, y)
返回欧几里德范数 sqrt(xx + yy)。
sin(x)
返回的x弧度的正弦值。
tan(x)
返回x弧度的正切值。
degrees(x)
将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)
将角度转换为弧度

数学常量：pi，e

2.3.1.1 Python支持四种不同的数字类型：

• int(有符号整型)
• long(长整形[也可以代表八进制和十六进制])
• float(浮点型)
• complex(复数)

长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。
Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

2.3.2 Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :

s="a1a2···an"(n>=0)

它是编程语言中表示文本的数据类型。
python的字串列表有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
比如:

>>> s = 'abcdef'
>>> s[1:5]
'bcde'

加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
实例(Python 2.0+)

str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串

以上实例输出结果：

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

字符串是 Python 中最常用的数据类型。我们可以使用引号(‘或”)来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

字符串更新

var1 = 'Hello yelin'
print('',var1[:6]+'hongsheng')

Python转义字符

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

Python字符串运算符
下表实例变量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    原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print( r'\n' )
print( R'\n' )
%    格式字符串    请看下一节内容。

Python字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

print ("我叫 %s 今年 %d 岁!" % ('小乌兰', 10))

Python2.6开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。

*    定义宽度或者小数点精度 
-    用做左对齐 
+    在正数前面显示加号( + ) 
<sp>    在正数前面显示空格 
#    在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0    显示的数字前面填充'0'而不是默认的空格 
%    '%%'输出一个单一的'%' 
(var)    映射变量(字典参数) 
m.n.    m是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

Unicode 字符串
在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中，所有的字符串都是Unicode字符串。

Python的字符串内建函数

1    capitalize()
将字符串的第一个字符转换为大写
2    center(width, fillchar)    
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3    count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4   bytes.decode(encoding="utf-8", errors="strict")
Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5    encode(encoding='UTF-8',errors='strict')
以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6    endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7    expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8    find(str, beg=0 end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9    index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10    isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11    isalpha()
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12    isdigit()
如果字符串只包含数字则返回 True 否则返回 False..
13    islower()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14    isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False
15    isspace()
如果字符串中只包含空白，则返回 True，否则返回 False.
16    istitle()
如果字符串是标题化的(见 title())则返回 True，否则返回 False
17    isupper()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18    join(seq)
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19    len(string)
返回字符串长度
20    ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21    lower()
转换字符串中所有大写字符为小写.
22    lstrip()
截掉字符串左边的空格或指定字符。
23    maketrans()
创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24    max(str)

返回字符串 str 中最大的字母。
25    min(str)

返回字符串 str 中最小的字母。
26    replace(old, new [, max])

把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27    rfind(str, beg=0,end=len(string))

类似于 find()函数，不过是从右边开始查找.
28    rindex( str, beg=0, end=len(string))

类似于 index()，不过是从右边开始.
29
rjust(width,[, fillchar])

返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30    rstrip()

删除字符串字符串末尾的空格.
31    split(str="", num=string.count(str))

num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
32    splitlines([keepends])

按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33    startswith(str, beg=0,end=len(string))

检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34    strip([chars])

在字符串上执行 lstrip()和 rstrip()
35    swapcase()

将字符串中大写转换为小写，小写转换为大写
36
title()

返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37    translate(table, deletechars="")

根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38    upper()

转换字符串中的小写字母为大写
39    zfill (width)

返回长度为 width 的字符串，原字符串右对齐，前面填充0
40    isdecimal()
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

2.3.3 Python列表

List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。

**list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]**
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

以上实例输出结果：

['runoob', 786, 2.23, 'john', 70.2]

2.3.4 Python 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用”{ }”标识。字典由索引(key)和它对应的值value组成。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name':'john','code':6743,'dept':'sales'}

print (dict['one'])          # 输出键为'one' 的值
print (dict[2])              # 输出键为 2 的值
print (tinydict)             # 输出完整的字典
print (tinydict.keys())      # 输出所有键
print (tinydict.values())    # 输出所有值

输出结果为：

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

2.3.5 Python 元组

2. Python的内置函数

2.1内置函数set( )
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
set 语法：

class set([iterable])

参数说明：
iterable — 可迭代对象对象；
返回值
返回新的集合对象。

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])
  

2.1内置函数sorted( )
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：
iterable — 可迭代对象。
cmp — 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key — 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse — 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值
返回重新排序的列表。

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]

难点：https://www.runoob.com/python…

>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

例二：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2]))
print(type(students))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
<class 'list'>

5.给文件夹的名字加前缀：

import os
movie_name = os.listdir('E:\中化能源科技新事业部-期待成长\MakeTag\BEBABOO')
for temp in movie_name:
    new_name = 'WL' + temp
    os.rename('E:\中化能源科技新事业部-期待成长\MakeTag\BEBABOO/'+temp,'E:\中化能源科技新事业部-期待成长\MakeTag\BEBABOO/'+new_name)