本文详细介绍了Python的基础语法，包括字符串操作、基本数据类型、条件与循环控制等内容。文章通过实例展示了如何使用Python进行常见任务的处理。
Python
--------------------------------------基础语法--------------------------------------
1.反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。如 print ( r "this is a linewith \n") 则\n会显示，并不是换行。
2.字符串可以用 + 运算符连接在一起，用 * 运算符重复。
3.Python中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
4. str='Runoob'
print(str) #输出字符串
print(str[0:-1]) #输出第一个到倒数第二个的所有字符
print(str[0]) #输出字符串第一个字符
print(str[2:5]) #输出从第三个开始到第五个的字符
print(str[2:]) #输出从第三个开始的后的所有字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
5. 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
6. Python可以在同一行中使用多条语句，语句之间使用分号(;)分割。
7. print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end="" 例如：print(x, end=" " )
8. 在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入多个函数,格式为：from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为：from somemodule import *
--------------------------------------基本数据类型--------------------------------------
9.多个变量赋值：a = b = c = 1 或 a, b, c = 1,2, "runoob"
10. Python3 的六个标准数据类型中：
不可变数据：Number（数字）、String（字符串）、Tuple（元组）、Sets（集合）；
可变数据 ：List（列表）、Dictionary（字典）。
11. 可以使用del语句删除一些对象引用。例如： del var
12.数值运算：
2 / 4 # 除法，得到一个浮点数
2 // 4 # 除法，得到一个整数
2 ** 5 # 乘方
13. Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
14.列表list：列表中的元素是可以改变，写在 [ ] 之中
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123,'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list +tinylist) # 连接列表
15.元组 tuple：元组的元素不能修改，元组写在小括号 ( ) 里 实例如列表
16.集合 set： 集合是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为{ } 是用来创建一个空字典。
创建格式： parame = { value01,value02,...} 或者 set( value )
实例：
student = {'Tom', 'Jim', 'Mary', 'Tom','Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if('Rose' in student):
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以进行集合运算
a =set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
17.字典 Dictionary：列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
实例：
rint(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
构造函数 dict() 可以直接从键值对序列中构建字典如下：
dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
{x: x**2forxin(2, 4, 6)}
{2: 4, 4: 16, 6: 36}
dict(Runoob=1, Google=2, Taobao=3)
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
--------------------------------------解释器--------------------------------------
略
--------------------------------------注释--------------------------------------
略
--------------------------------------运算符--------------------------------------
18. 算术运算符：
** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
// | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
位运算符：
运算符 | 描述 | 实例 |
& | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。 |
<< | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
>> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
成员运算符： 例如： if ( a in list ):
运算符 | 描述 | 实例 |
in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
身份运算符：
运算符 | 描述 | 实例 |
is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则 返回 True，否则返回 False |
is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
注：id()函数用于获取对象内存地址
运算符优先级：
运算符 | 描述 |
** | 指数 (最高优先级) |
~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // | 乘，除，取模和取整除 |
+ - | 加法减法 |
>> << | 右移，左移运算符 |
& | 位 'AND' |
^ | | 位运算符 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not or and | 逻辑运算符 |
--------------------------------------数字--------------------------------------
19.转换虚数：
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
20.数学函数：
函数 | 返回值 ( 描述 ) |
返回数字的绝对值，如abs(-10) 返回 10 | |
返回数字的上入整数，如math.ceil(4.1) 返回 5 | |
cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。 使用 使用 (x>y)-(x<y) 替换。 |
返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 | |
返回数字的绝对值，如math.fabs(-10) 返回10.0 | |
返回数字的下舍整数，如math.floor(4.9)返回 4 | |
如math.log(math.e)返回1.0,math.log(100,10)返回2.0 | |
返回以10为基数的x的对数，如math.log10(100)返回 2.0 | |
返回给定参数的最大值，参数可以为序列。 | |
返回给定参数的最小值，参数可以为序列。 | |
返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 | |
x**y 运算后的值。 | |
返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 | |
返回数字x的平方根。 |
--------------------------------------字符串--------------------------------------
21.字符串更新：print("已更新字符串 : ", var1[:6] + 'Runoob!')
22.转义字符：
转义字符 | 描述 |
\(在行尾时) | 续行符 |
\\ | 反斜杠符号 |
\' | 单引号 |
\" | 双引号 |
\a | 响铃 |
\b | 退格(Backspace) |
\e | 转义 |
\000 | 空 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 换页 |
\oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
\xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
\other | 其它的字符以普通格式输出 |
23.字符串格式化符号：
符 号 | 描述 |
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数（大写） |
%f | 格式化浮点数字，可指定小数点后的精度 |
%e | 用科学计数法格式化浮点数 |
%E | 作用同%e，用科学计数法格式化浮点数 |
%g | %f和%e的简写 |
%G | %f 和 %E 的简写 |
%p | 用十六进制数格式化变量的地址 |
24.数字格式化 print("{:.2f}".format(3.1415926));
数字 | 格式 | 输出 | 描述 |
3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
-1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
2.71828 | {:.0f} | 3 | 不带小数 |
5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
0.25 | {:.2%} | 25.00% | 百分比格式 |
1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
13 | {:10d} | 13 | 右对齐 (默认, 宽度为10) |
13 | {:<10d} | 13 | 左对齐 (宽度为10) |
13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
11 |
'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) |
1011 11 13 b 0xb 0XB | 进制 |
25. python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。（也即：\n 会换行）
26.字符串内建函数：
序号 | 方法及描述 |
1 | capitalize() |
2 | center(width, fillchar) |
3 | count(str, beg= 0,end=len(string)) |
4 | bytes.decode(encoding="utf-8", errors="strict") 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
5 | encode(encoding='UTF-8',errors='strict') 的是'ignore'或者'replace' |
6 | endswith(suffix, beg=0, end=len(string)) |
7 | expandtabs(tabsize=8) |
8 | find(str, beg=0 end=len(string)) |
9 | index(str, beg=0, end=len(string)) |
10 | isalnum() |
11 | isalpha() |
12 | isdigit() |
13 | islower() True，否则返回 False |
14 | isnumeric() |
15 | isspace() |
16 | istitle() |
17 | isupper() True，否则返回 False |
18 | join(seq) |
19 | len(string) |
20 | ljust(width[, fillchar]) |
21 | lower() |
22 | lstrip() |
23 | maketrans() 的字符，第二个参数也是字符串表示转换的目标。 |
24 | max(str) |
25 | min(str) |
26 | replace(old, new [, max]) |
27 | rfind(str, beg=0,end=len(string)) |
28 | rindex( str, beg=0, end=len(string)) |
29 | rjust(width,[, fillchar]) |
30 | rstrip() |
31 | split(str="", num=string.count(str)) |
32 | splitlines([keepends]) 换行符，如果为 True，则保留换行符。 |
33 | startswith(str, beg=0,end=len(string)) 指定范围内检查。 |
34 | strip([chars]) |
35 | swapcase() |
36 | title() |
37 | translate(table, deletechars="") |
38 | upper() |
39 | zfill (width) |
40 | isdecimal() |
--------------------------------------列表--------------------------------------
27.列表举例：list3 = ["a", "b", "c", "d"];
28.列表操作符：
Python 表达式 | 结果 | 描述 |
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, end=" ") | 1 2 3 | 迭代 |
29.列表函数、方法：
函数：
序号 | 函数 |
1 | len(list) |
2 | max(list) |
3 | min(list) |
4 | list(seq) |
方法：
序号 | 方法 |
1 | list.append(obj) |
2 | list.count(obj) |
3 | list.extend(seq) |
4 | list.index(obj) |
5 | |
6 | list.pop(obj=list[-1]) |
7 | list.remove(obj) |
8 | list.reverse() |
9 | list.sort([func]) |
10 | list.clear() |
11 | list.copy() |
--------------------------------------元组--------------------------------------
30. Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
31. 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
>>> tup1 = (50)
>>>type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 =(50,)
>>>type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
32.元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
33.元组运算符：
Python 表达式 | 结果 | 描述 |
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 | 迭代 |
34.元组内置函数：
序号 | 方法及描述 | 实例 |
1 | len(tuple) |
>>> tuple1 =('Google','Runoob','Taobao') >>> len(tuple1) 3 >>> |
2 | max(tuple) |
>>> tuple2 =('5','4','8') >>> max(tuple2) '8' >>> |
3 | min(tuple) |
>>> tuple2 =('5','4','8') >>> min(tuple2) '4' |
4 | tuple(seq) |
>>> list1=['Google','Taobao','Runoob','Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google','Taobao','Runoob','Baidu') |
--------------------------------------字典--------------------------------------
35. 字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：d = { key1 : value1 , key2 : value2 }
36. 键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例： dict = { 'Alice': '2341' , 'Beth' : '9102' , 'Cecil' : '3258'}
37. 访问字典里的值：把相应的键放入熟悉的方括弧，如下实例:
print ( "dict['Age'] : " , dict['Age'] ) 输出：dict['Age']: 7
38.修改字典： dict ['Age'] =8;
39.删除字典：
del dict ['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
40. 字典键的特性：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
41. 字典内置函数&方法
内置函数：
序号 | 函数及描述 | 实例 |
1 | len(dict) |
>>> dict ={'Name':'Runoob','Age':7,'Class':'First'} >>> len(dict) 3 |
2 | str(dict) |
>>> dict ={'Name':'Runoob','Age':7,'Class':'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" |
3 | type(variable) |
>>> dict ={'Name':'Runoob','Age':7,'Class':'First'} >>> type(dict) <class'dict'> |
内置方法：
序号 | 函数及描述 |
1 | radiansdict.clear() |
2 | radiansdict.copy() |
3 | radiansdict.fromkeys() |
4 | radiansdict.get(key, default=None) |
5 | key in dict |
6 | radiansdict.items() |
7 | radiansdict.keys() |
8 | radiansdict.setdefault(key, default=None) |
9 | radiansdict.update(dict2) |
10 | radiansdict.values() |
11 | pop(key[,default]) |
12 | popitem() |
--------------------------------------编程第一步--------------------------------------
--------------------------------------条件控制--------------------------------------
42.if条件语句
ifcondition_1:
statement_block_1
elifcondition_2:
statement_block_2
else:
statement_block_3
注意：1、每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch–case语句。
43.if嵌套：可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中
if 表达式1:
语句
if 表达式2:
语句
elif表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句
--------------------------------------循环语句--------------------------------------
44.循环语句分为whlie和for循环，在Python中没有do.while循环。
while 判断条件：
语句
45. 以使用CTRL+C来退出当前的无限循环
46. while循环使用else语句：在 while … else 在条件语句为 false 时执行else的语句块：
例如：count = 0
whilecount < 5:
print(count, "小于 5")
count = count + 1
else: print(count, "大于或等于 5")
47. Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
48. Python loop循环实例：以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：
sites = ["Baidu", "Google","Runoob","Taobao"]
forsiteinsites:
ifsite == "Runoob":
print("菜鸟教程!")
break
print("循环数据" + site)
else:
print("没有循环数据!")
print("完成循环!")
49. range()函数: 如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如: foriinrange(5,9):
也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做步长，
例如：oriinrange(0, 10, 3) :
--------------------------------------Python3 迭代器与生成器--------------------------------------
50. 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
>>>list=[1,2,3,4]
>>> it = iter(list)# 创建迭代器对象
>>> print(next(it))# 输出迭代器的下一个元素
1
>>> print(next(it))
2
51. 在 Python 中，使用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象。
--------------------------------------函数--------------------------------------
52. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
53. def print_welcome(name):
Print ("Welcome", name)
print_welcome ("Runoob")
Dr_JaiWang
2018.5.14
56. 王
5
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
