基本语法
#Python保留字
import keyword
keyword.kwlist
['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']
#注释
print("Hello Python")
#注释1
'''
注释2
'''
"""
注释3
"""
Hello Python
'\n注释3\n'
#行与缩进
#缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
if True:
print("True")
else:
print("False")
True
if True:
print("True1")
print("True2")
else:
print("False")
print("Ecust")
True1
True2
Ecust
#多行语句
#语句过长可以使用反斜杠(\)来实现多行语句
total = 1 + \
2 + 3
print(total)
#在[],{},()中的多行语句，不需要使用反斜杠
total1 = ['a',
'b','c']
print(total1)
6
['a', 'b', 'c']
#数字类型
#int(整数)，表示为长整型，没有long
#bool
#float
#complex 复数
#字符串
#单引号和多引号使用完全相同
#转义符'\'
#反斜杠可以用来转义，使用r可以使反斜杠不转义
print("\nEcust\n")
print(r"\nEcust\n")
#字符串可以用+运算符连接在一起
Ecust = "Ecust" + "Handsome"
print(Ecust)
#字符串有两种索引方式，从左往右从0开始，从右往左从-1开始
#字符串不能改变
#python没有单独的字符类型
#字符串的截取语法：变量[头下标:尾下标]
str = "ECUST"
print(str)
print(str[0:-1])
print(str[2:4])
print(str[2:])
print(str[:-2])
print(str * 2)
print(str + "NB")
Ecust
\nEcust\n
EcustHandsome
ECUST
ECUS
US
UST
ECU
ECUSTECUST
ECUSTNB
#用户输入
input("\n\n按下enter键后退出")
按下enter键后退出
''
#同一行显示多条语句
#可以使用分号（;）分割以使用多条语句
import sys; x = 'ECUST'; sys.stdout.write(x + '\n')
ECUST
#代码组
if expression:
suite
elif expression:
suite
else:
suite
#print输出
x = 'a'
y = 'b'
print(x)
print(y)
#不换行输出
print(x,end = ' ')
print(y,end = ' ')
a
b
a b
#将整个模块导入 import somemodule
#将某个模块中导入某个函数 from somemodule import somefunction
#将某个模块中导入多个函数 from somemodule import firstfunc,secondfunc,thirdfunc
#将某个模块中的全部函数导入 from somemodule import *
#导入sys模块
import sys
for i in sys.argv:
print(i)
print('\n python 路径为',sys.path)
from sys import argv,path
print('path:',path)#因为已经导入path成员，所以此处引用时不需要加sys.path
G:\Anaconda3\lib\site-packages\ipykernel_launcher.py
-f
C:\Users\asus\AppData\Roaming\jupyter\runtime\kernel-129790c9-1b68-4f46-a22f-3f22c933a8d2.json
python 路径为 ['', 'G:\\Anaconda3\\python36.zip', 'G:\\Anaconda3\\DLLs', 'G:\\Anaconda3\\lib', 'G:\\Anaconda3', 'G:\\Anaconda3\\lib\\site-packages', 'G:\\Anaconda3\\lib\\site-packages\\win32', 'G:\\Anaconda3\\lib\\site-packages\\win32\\lib', 'G:\\Anaconda3\\lib\\site-packages\\Pythonwin', 'G:\\Anaconda3\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\asus\\.ipython']
path: ['', 'G:\\Anaconda3\\python36.zip', 'G:\\Anaconda3\\DLLs', 'G:\\Anaconda3\\lib', 'G:\\Anaconda3', 'G:\\Anaconda3\\lib\\site-packages', 'G:\\Anaconda3\\lib\\site-packages\\win32', 'G:\\Anaconda3\\lib\\site-packages\\win32\\lib', 'G:\\Anaconda3\\lib\\site-packages\\Pythonwin', 'G:\\Anaconda3\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\asus\\.ipython']
基本数据类型
#多个变量赋值
a = 100
b = 100.02
c = "ECUST"
print(a,b,c)
a = b = c = 1#允许同时为多个变量赋值
print(a,b,c)
a,b,c = 1,2,32
print(a,b,c)
100 100.02 ECUST
1 1 1
1 2 32
#标准数据类型
#Number String List Tuple(元祖) Set（集合） Dictionary（字典）
#不可变数据：Number，String，Tuple
#可变数据：List，Dictionary，Set
#Number
#int,float,bool,complex 没有long
a,b,c,d = 20,5.5,True,4+3j
print(type(a),type(b),type(c),type(d))
#还可以通过isinstance来判断：
a = 1.1
isinstance(a,float)
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
True
#del语句删除一些对象引用
var = 1
print(var)
del var
print(var)
1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-64-70d2bd7b4b56> in <module>()
3 print(var)
4 del var
----> 5 print(var)
NameError: name 'var' is not defined
#数值计算
a = 2 / 4 #除法，得到一个浮点数
b = 2 // 4 #除法，得到一个整数
c = 17 % 3 #求余
d = 2 ** 5 #乘方
print(a,b,c,d)
#在混合运算时Python会把整形转换成为浮点数
0.5 0 2 32
#字符串
str = 'Runoob'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符 （左闭右开）
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次
print (str + "TEST") # 连接字符串
Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST
word = 'Python'
print(word[0],word[5])
print(word[-1],word[-6])
P n
n P
#列表
#Python中使用最频繁的数据类型
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) # 连接列表
['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
#列表中元素是可以改变的
a = [1,2,3,4,5,6]
a[0] = 9
a[2:5] = [13,15,45]
print(a)
a[2:5] = ["xuhuan"]
print(a)
[9, 2, 13, 15, 45, 6]
[9, 2, 'xuhuan', 6]
#Tuple（元祖）
#元祖与列表相似，不同之处在于元祖的元素不能修改
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
tup = (1,2,3,4,5,6)
print(tup[0])
print(tup[0,5])
tup[0] = 15 #修改元祖元素的操作是非法的
1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-77-5a5b7e999565> in <module>()
1 tup = (1,2,3,4,5,6)
2 print(tup[0])
----> 3 print(tup[0,5])
4 tup[0] = 15 #修改元祖元素的操作是非法的
TypeError: tuple indices must be integers or slices, not tuple
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
#String、list、Tuple 都属于 sequence（序列）
#元组也可以使用+操作符进行拼接
#与字符串一样，元组的元素不能修改。
#Set（集合）
#集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。
#可以使用大括号 { } 或者 set() 函数创建集合
#注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
student = {'zhang','yan','chen','zhang','yi','xu'}
print(student)
#输出集合，重复的元素被自动去掉
if 'xu' in student:
print("xu在集合中")
else:
print("xu不在集合中")
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
{'xu', 'zhang', 'chen', 'yan', 'yi'}
xu在集合中
{'r', 'a', 'b', 'c', 'd'}
{'m', 'l', 'a', 'c', 'z'}
{'d', 'r', 'b'}
{'r', 'm', 'z', 'l', 'a', 'b', 'c', 'd'}
{'c', 'a'}
{'l', 'd', 'r', 'b', 'm', 'z'}
#Dictionary(字典)
#列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
#字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
#键(key)必须使用不可变类型。
#在同一个字典中，键(key)必须是唯一的。
dict = {}
dict['one'] = "Ecust"
dict[2.2] = 'Xuhuan'
print(dict['one'])
print(dict[2.2])
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
#构造函数dict()可以直接从键值对序列中构造字典：
del(dict)
a = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
print(a)
b = {x:x**2 for x in(2,4,6)}
print(b)
c = dict(Runoob = 1,Google = 2,Facebook = 3)
print(c)
Ecust
Xuhuan
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
{2: 4, 4: 16, 6: 36}
{'Runoob': 1, 'Google': 2, 'Facebook': 3}
Python数据类型转换
int(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)
将一个整数转换为一个字符
ord(x)
将一个字符转换为它的整数值
hex(x)
将一个整数转换为一个十六进制字符串
oct(x)
将一个整数转换为一个八进制字符串
注释
#单引号注释
'''
ECUST
'''
#双引号注释
"""
Xuhuan
"""
'\nXuhuan\n'
运算符
#算术运算符
a = 21
b = 10
c = 0
c = a + b
print(c)
c = a - b
print(c)
c = a * b
print(c)
c = a / b#除法，输出浮点数
print(c)
c = a % b
print(c)
a = 2
b = 3
c = a ** b
print(c)
a = 10
b = 4
c = a // b#除法，输出整数
print(c)
31
11
210
2.1
1
8
2
#比较运算符
a = 21
b = 10
c = 0
if(a == b):
print('a等于b')
else:
print('a不等于b')
if(a != b):
print('a不等于b')
else:
print('a等于b')
if(a < b):
print('a小于b')
else:
print('a大于等于b')
if(a >= b):
print('a大于等于b')
else:
print('a小于b')
a不等于b
a不等于b
a大于等于b
a大于等于b
#赋值运算符
a = 21
b = 10
c = 0
c = a + b
print(c)
c += a
print(c)
c *= a
print(c)
c /= a
print(c)
c = 2
c %= a
print(c)
c **= a
print(c)
c //= a
print(c)
31
52
1092
52.0
2
2097152
99864
#位运算符
a = 60 # 60 = 00111100
b = 13 # 13 = 00001101
c = 0
c = a&b
print(c) # 12 = 00001100
c = a|b
print(c) # 61 = 00111101
c = a^b # 异或
print(c) # 49 = 00110001
c = ~a
print(c) # -61 = 11000011
c = a << 2
print(c) # 240 = 11110000
c = a >> 2
print(c) # 15 = 00001111
12
61
49
-61
240
15
a = 10
b = 20
if(a and b):
print('a和b都是true')
else:
print('有一个不是true')
if(a or b):
print('一个以上是true')
else:
print('有一个不是true')
a = 0
if(a and b):
print('a和b都是true')
else:
print('有一个不是true')
if(a or b):
print('一个以上是true')
else:
print('有一个不是true')
if not(a and b):
print('不全是true')
else:
print('全是true')
a和b都是true
一个以上是true
有一个不是true
一个以上是true
不全是true
# 成员运算符
# 【in】 如果在指定的序列中找到值返回 True，否则返回 False。
# 【not in】 如果在指定的序列中没有找到值返回 True，否则返回 False。
#包括字符串，列表和元祖
a = 10
b = 20
list = [1,2,3,4,5]
if(a in list):
print("yes")
else:
print("no")
if(a not in list):
print("no")
else:
print("yes")
a = 2
if(a in list):
print("yes")
else:
print("no")
no
no
yes
# 身份运算符
# 【is】 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
# 【not is】 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
a = 20
b = 20
if(a is b):
print('有相同的标识')
else:
print('没有相同的标识')
if(id(a) == id(b)):
print('有相同的标识')
else:
print('没有相同的标识')
a = 15
if(a is b):
print('有相同的标识')
else:
print('没有相同的标识')
if(id(a) == id(b)):
print('有相同的标识')
else:
print('没有相同的标识')
#is和==区别： is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
a = [1,2,3]
b = a
print(b==a)
print(b is a)
b = a[:]
print(b == a)
print(b is a)
有相同的标识
有相同的标识
没有相同的标识
没有相同的标识
True
True
True
False
#运算符优先级
"""
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 'AND'
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
and or not 逻辑运算符
"""
"\n**\t指数 (最高优先级)\n~ + -\t按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)\n* / % //\t乘，除，取模和取整除\n+ -\t加法减法\n>> <<\t右移，左移运算符\n&\t位 'AND'\n^ |\t位运算符\n<= < > >=\t比较运算符\n<> == !=\t等于运算符\n= %= /= //= -= += *= **=\t赋值运算符\nis is not\t身份运算符\nin not in\t成员运算符\nand or not\t逻辑运算符\n"