Python3-2020/2/22-基础1

Python3基础语法

编码

默认情况下，Python3源码文件以UTF-O编码，所有的字符串都是unicode字符串。

标识符

第一个字符必须是字母或下划线_
其他部分由字母，数字和下划线组成
大小写敏感

python保留字

'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

注释

#为单行注释
多行注释可以使用多个#，’’’和”””

行与缩进

由于python的特色，需要分号作为结尾，也不需要{}来表示代码块，所以缩进尤为重要，是python区分不同代码块的重要环节；缩进的空格数可变，同一个代码块必须包含相同的缩进空格数
例如：

if True:
    print ("True")
else:
    print ("False")

多行语句

python通常是一行写完，如果语句很长，使用\反斜杠来实现多行语句

在[].{}.()中的多行语句不需要反斜杠

数据类型

python有四种数据类型：整型，布尔型，浮点数和复数

int(整型)  如1
bool(布尔)  如ture
float(浮点数)  如1.23
complex(复数)  如1+2j

字符串

python中单引号与双引号使用相同

三引号'''可以指定一个多行字符串

转义符\

反斜杠可以转义，使用r可以让反斜杠不发生转义。如r”this is a line with \n” \n会正常显示 而不是换行

按字面意义级联字符串。如”this””is””string”会被自动转换为this is string

字符串可以用+连接，用*重复

python中字符串有两种索引方式，从左开始以0开始，从右开始以-1开始

字符串不可以改变

没有单独的字符类型，一个字符就是长度为1的字符串

字符串截取的语法格式为：变量[头下标:尾下标:步长]

str='Runoob'

print(str)  	#输出字符串
print(str[0:-1]) 	#输出第一个到倒数第二个的所有字符
print(str[0]) 	#输出第一个字符
print(str[2:5]) 	#输出从第三个开始到第五个的字符
print(str + ‘你好’) 	#连接字符串
print('hello\nrunoob') 	#反斜杠转义
print(r'hello\nrunoob') 	#在字符串前加一个r，不发生转义

访问字符串中的值

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

结果为：
var1[0]:  H
var2[1:5]:  unoo

字符串更新

var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Runoob!')

结果为：
已更新字符串 :  Hello Runoob!

字符串运算符

+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e

例如：

a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])

结果为：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell

三引号

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str

结果为：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

常用字符串函数

capitalize()  第一个字符转大写

center(width,fillchar)  指定一个宽度width居中的字符串，fillchar位填充的字符，默认为空格

count(str,beg=0,end=len(string))  返回str在string中出现的次数，beg和end可以指定范围

encode(encoding='UTF-8',errors='strict')  以encoding指定的编码格式编码字符串

find(str,beg=0,end=len(string))  查找str字符是否在string中，beg和end指定范围

upper()  小写转大写

lower()  大写转小写

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

islower()  如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isupper()  类似

len()  返回字符串长度

max(str)  返回最大值
min类似

replace(old,new[,max])  把字符串中的str1转换成str2，如果max指定，替换不超过max次

split(str"",num=string.count(str))  以str为分隔符截取字符串

列表

类似于一个数组

访问列表中的值

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
 
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

结果为：
list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]

删除列表元素

list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

结果为：
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

列表脚本操作符

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  迭代

列表常用函数

len(list)  列表元素个数

max(list)  返回列表元素最大值

min(list)  返回列表元素最小值

list(seq)  将元组转换为列表

列表常用方法

list.append(obj)  在末尾添加新的对象

list.count(obj)  统计某个元素出现的个数

list.extend(seq)  在列表末尾一次性追加另一个序列中的多个值

list.insert(index,obj)  将对象插入列表

list.remove(obj)  移除列表中某个值的第一个匹配项

list.pop([index=-1])  移除列表中的一个元素，并且返回该元素

list.sort(key=None,reverse=False)  对列表进行排序

list.clear()  清空列表

元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改

元组使用小括号，列表使用方括号

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

元组是不可变的

访问元组

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

结果为：
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

删除元组

tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

结果为：
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

元组运算符

与列表几乎一致

元组常用函数

tuple(iterable)  将可迭代系列转换为元组

其余函数与列表相同

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中

访问字典里的值

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

结果为：
dict['Name']:  Runoob
dict['Age']:  7

删除字典元素

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

结果为：
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable

字典键的特性

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

字典常用函数

len(dict)  计算字典元素个数，即键的总数

str(dict)  输出字典，以可打印的字符串表示

type(variable)  返回输入的变量类型，如果变量是字典就返回字典类型

字典常用方法

radiansdict.clear()  删除字典内所有元素

radiansdict.get(key, default=None)  返回指定键的值，如果值不在字典中返回default值

radiansdict.items()  以列表返回可遍历的(键, 值) 元组数组

radiansdict.values()  返回一个迭代器，可以使用 list() 来转换为列表

用户输入

input("\n\n按下enter键后退出")

同一行显示多条语句

语句之间必须用分号分隔

import sys;x='runoob';sys.stdout.write(x+'\n')

输出结果为：

runoob

多个语句构成代码组

像if,while,de和class这样的复合语句，首行以关键字开始，以冒号结束

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

print 输出

默认换行，不需要换行在变量尾部加上end=””

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

执行结果为：

a
b
---------
a b

import与from…import

在 python 用 import 或者 from…import 来导入相应的模块
将某个模块中的全部函数导入，格式为： from somemodule import *

导入sys模块

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

命令行参数

Python -h查看帮助

运算符

运算符分为算数运算符，比较运算符，赋值运算符，逻辑运算符，位运算符，成员运算符，身份运算符

算数运算符

以下假设变量a为10，变量b为21:

+	加 - 两个对象相加	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

比较运算符

以下假设变量a为10，变量b为20：

==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假.	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

赋值运算符

以下假设变量a为10，变量b为20：

=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

位运算符

&	 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0（a & b) 输出结果 12
|	 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。(a | b) 输出结果 61
^	 按位异或运算符：当两对应的二进位相异时，结果为1(a ^ b) 输出结果 49
~	 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。在一个有符号二进制数的补码形式。
<<	 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。a << 2 输出结果 240
>>	 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15

逻辑运算符

假设变量 a 为 10, b为 20:
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	
				not(a and b) 返回 False

例如：

a = 0
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
   
   
结果为：
1 - 变量 a 和 b 有一个不为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true

成员运算符

in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

例如：

a = 2
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
   
   
结果为：
1 - 变量 a 在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中

身份运算符

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。

例如：

a = 20
b = 30
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
   
结果为：
1 - a 和 b 没有相同的标识
2 - a 和 b 没有相同的标识

常用数学函数

abs(x)  返回数字的绝对值 如abs(-10) 返回 10

ceil(x)  向上取整 如math.ceil(4.1) 返回 5

floor(x)  向下取整 如math.floor(4.9)返回 4

exp(x)  返回e的x次幂(ex) 如math.exp(1) 返回2.718281828459045

sqrt(x)  求平方根

acos(x)  返回x的反余弦弧度值

cos(x)  返回x的弧度的余弦值

sin,tan类似

常用随机数函数

choice(seq)  从序列元素中随机挑选一个元素 比如random.choice(range(10))，从0到9中随机挑选一个整数

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

randrange ([start,] stop [,step])  从指定范围内 按指定基数递增的集合中获取一个随机数 基数默认值为 1

数学常量

pi 数学常量pi 圆周率
e  数学常量e 自然常数

周报总结：

1.python语言较为简单，但是也面临着一个新的问题，由于python不需要用;来代表语句结束，{}代表代码块，而是使用TAB和空格来进行区分，所以要严格控制TAB和空格的数量，以便区分每个语句或代码块

2.if while这些复合语句，不像C或者JAVA一样有{}，需要在if [条件] 之后加:表示代码块的开始

3.import是导入整个模块，from...import是导入某个模块中的某个函数，第二种更为灵活，可以减少时间复杂度，提高效率和辨识度

4.输入和输出都较为简单，input和print与python2的区别就是需要加括号而不是空格

5.字符串可以实现多行代码但是需要用三引号括住

6.字符串不可更改

7.python对大小写敏感

8.反斜杠在python中需要慎用，有可能会造成转义而形成不必要的麻烦

9.python引入了成员运算符（in 和 not in） 可以更加方便地对数据进行查找