语法基本
1.运算符
常见的运算符 + - * / % =
python特殊:’**’表示乘方
# **的优先级高,负号要括号
a= (-2)**3 #负号
变量号如果未(定义/赋值),将会报错
n #wrong
2.字符串
定义字符串
’‘ “” 括起来,含义是一样的
字符串
'AAA' == "AAA"
'\"\"' #\表示转义字符
如果不希望\ 转义的话
print(r'1\**') #这样子不会转义
跨行连续输入："""..."""或''' ... '''
print("""\
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
)
字符串操作
字符串合并
字符串使用+来合并,也可以用*来重复
3 * 'un' + 'inm'
/'py' 'thon' 两个或者多个字符串字面值相邻,会自动合并
这个功能只用于两个字面值,不用于变量或表达式
A 'thon' #wrong
('un'*3) 'inum' #wrong
合并多个变量,或者变量+字面值,要用+
A +'thon'
字符串索引
字符串支持下标索引,从0开始索引
单字符没有专门的类型,就是长度为一的字符串
字符串支持负数索引,用负数索引,从右边开始计数
word[-1] == word[word.lenth()-2]
-0和0一样,负数索引从-1开始
字符串切片
字符串切片,是用来提取子串
word[0:2]
字符串具有默认值
- :左边,默认值为0
- :右边,默认到结尾
同时支持负数的切片,但是切片要保证左边的字符下标<=右边的字符下标
例如
a="12345"
print(a[-1:2]) #这样子不会输出因为 [4~2]
-
printf(a[-5:7]) #这样子会输出,同时,切片索引的左右边不会越界
越界默认是(-长度)或(+长度)
索引结点会报错
字符串特性
python的字符串是不能修改的,不能对某个索引位置赋值
要生成不同字符串,应该新建一个字符串
len()可以返回字符串长度
s = 'qaqaqaq'
len(s)
3.列表
列表是特殊的数组,因为列表支持不同的数据类型组合在一起
squares = [1, 4, 9, 16, 25]
列表也支持索引和切片
切片操作会返回包含请求元素的新列表
c=squares[:]
列表支持合并操作：
squares + [1, 2, 3, 4]
与字符串不同,列表的内容是可以改变的
append()可以在列表结尾添加新的元素
a.append()
为切片赋值可以改变列表大小,甚至清空列表:
letters[2:5] = ['C', 'D', 'E'] #重新赋值
letters[2:5] = [] #清空2~5,大小被改变
len()函数也支持列表
可以嵌套列表
n = [1, 2, 3]
x = [n, 1]
[[1, 2, 3], 1]
python的新功能
多重赋值
a, b = 0, 1
while a < 10:
print(a)
a, b = b, a+b
流程控制语句
if语句
x = int(input())
if x < 0:
print(x)
elif x == 0:
print("zero")
elif x == 1:
print('single')
else:
print("qaq")
if与in 关键字
if ok in ('n', 'no', 'nop', 'nope'):
return False
if ok not in ('a','b'):
return true
for语句
auto迭代循环
类似于for(auto ...) ,for X in words:
words = ['cat','window','qaq']
for w in words:
print(w, len(w))
遍历集合时修改集合内容,应该遍历该集合的副本或创建新的集合
如果直接修改本集合,很容易出错
迭代拷贝集合,删除原集合
users = {'1':'QAQ', '2':'TAT', '3':'OVO'}
for id, task in users.copy().items():
print(id, task)
del users[id]
print(users)
直接创建一个新的集合
users = {'1':'QAQ', '2':'TAT', '3':'OVO'}
new_users = {}
for id, task in users.copy().items():
print(id, task)
new_users[id] = task
print(users)
数字迭代循环
range()函数可以生成一个数列
range(10) 生成0~9,从0开始长度为10的序列
range(5,10) 生成5~14,从5开始长度为10的序列
运用range函数可以产生类似数字迭代的效果
a = [1, 2, 3, 4, 5]
for i in range(4):
print(i)
range()和len()组合在一起
for i in range(len(a)):
print(i, a[i])
循环里的break、continue、else语句
a = [1, 2, 3, 4, 5]
for i in range(4):
if i == 1:
continue
print(i)
if i == 5:
break
else: #如果没有break,else子句会执行
print("no 5")
pass语句
pass语句不做任何操作,直接跳过
一般是用来作为占位符
函数
定义函数
def fib(n):
a, b = 0, 1
while a < n:
print(a)
a, b = b , a + b
fib(21)
函数可以进行赋值
f = fib
f(100)
函数如果不返回值,会返回一个None(类似于NULL)
函数返回值可以返回任意的东西
def fib2(n):
result = []
a, b = 0, 1
while a < n:
result.append(a) # see below
a, b = b, a+b
return result
函数参数
默认值参数
def check(a, b=2, c='please'):
print("a %d" % a)
print("b %d" % b)
print("c %s" % c)
check(111)
这个函数可以通过以下方式调用:
- 只给出必选实参 qaq(11)
- 给出一个可选实参 qaq(1,2)//原来的被覆盖
- 给出全部实参
关键字参数
def check(a, b=2, c='please'):
print("a %d" % a)
print("b %d" % b)
print("c %s" % c)
check(a=1,b=3,c="qaq")
该函数接受一个必选参数和其他的可选参数组合,该函数可用下列方式调用：
check(a=1,c="333")
这样子是错误的
check(a=1,"333")
关键字参数的顺序不重要
如果形参为**name，接受一个字典
*name,接受一个元组,name必须在**name前面
解包
运用*,可以解开数组
a =[1, 2]
print(*a)
运用**,可以解开集合
def make(a, b):
print("a %s" %a)
print("b %s" %b)
c = {'a':'qaq', 'b':'TAT'}
make(**c)
lambda表达式
def make_incrementor(n):
return lambda x: x + n
f = make_incrementor(42)
print(f(1))
数据结构
列表
-
list.append(x)
在列表末尾添加一个元素，相当于 a[len(a):] = [x] 。 -
list.extend(iterable)
用可迭代对象的元素扩展列表。相当于 a[len(a):] = iterable 。 -
list.insert(i, x)
在指定位置插入元素。第一个参数是插入元素的索引，因此，a.insert(0, x) 在列表开头插入元素，a.insert(len(a), x)等同于a.append(x)。 -
list.remove(x)
从列表中删除第一个值为 x 的元素。未找到指定元素时，触发 ValueError 异常。 -
list.pop([i])
删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，a.pop() 删除并返回列表的最后一个元素。 -
list.clear()
删除列表里的所有元素，相当于 del a[:] 。 -
list.index(x[, start[, end]])
返回列表中第一个值为 x 的元素的零基索引。未找到指定元素时，触发 ValueError 异常。 -
可选参数 start 和 end是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。 -
list.count(x)
返回列表中元素 x 出现的次数。 -
list.sort(*, key=None, reverse=False)
就地排序列表中的元素（要了解自定义排序参数，详见sorted()）。 -
list.reverse()
翻转列表中的元素。 list.copy()
返回列表的浅拷贝。相当于 a[:] 。
列表推导式
squares = [x**2 for x in range(10)]
del语句
del语句可以移除切片,移除索引
del语句也可以删除变量
del d[0]
del a[2:4]
del a
元组
元组是中间元素不可以修改的序列,元组中的单个元素不可以赋值
t = (123, 456, 'qaq')
a= (123, 456, 'qaq')
print(t)
但是元组中的列表,集合,是可以进行复制的
a= (123, 456, [123, 456, 7])
print(a)
a[2][1]=8
print(a)
元组可以进行解包
A, B, C =t
print(A, B, C)
集合
集合中的每个元素都不能重复,会自动去重
创建集合
a = {'a','b','v'}
a = set('abv')
创建空集合只能由set(),用{}创建的是空字典
集合还可以进行 & | ^ + -操作
a&b a|b a^b
字典
del用来删除键值对list(),返回字典中所有键的列表,按插入次序排列in用来寻找字典中是否有某个键
'guido' in tel
dict()构造函数,或者花括号构造
a = dict([('qaq',1),('tat',2)])
print(a)
b ={'qaq':'1','tat':'1'}
for循环遍历的时候，应该用items()可以同时取出键和值
for id,task in a.items():
print(id, task)
enumerate()可以同时取出位置索引和对应的值
for i, v in enumerate(['tic', 'tac', 'toe']):
print(i,v)
zip()函数可以将多个序列的元素一一匹配
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for a,b in zip(questions,answers):
print(a,':',b)
可以用sorted()函数排序,不改动原序列基础上,返回一个新的序列
b= sorted(answers)
print(b)
类
类的定义
类的定义
class ClassName:
...
...
构造器：
自动会带一个无参构造器
如果要定义一个带参构造器的话,需要如下操作,包含一个名为__init__()
的特殊方法
class Car:
def printf(self):
print("qaq")
def __init__(self,a):
print(a)
a =Car(1)
和java等面向对象语言一样,生成了带参构造器,原本的无参构造器将失效
所有类的成员方法,前面都需要加一个self
成员变量
如下创造成员变量的方法是错误的
class Car:
def printf(self):
print("qaq")
t = t+1
t = 1
def __init__(self,a):
print(a)
print(t)
可以在外部定义一个成员变量,但是在成员方法中并不能使用它,创建的是一个本地变量
class Car:
def __init__(self,a):
print(a)
self.t = 1
b = 2 #不会被改变,要写成 self.b = 2
print(self.t)
b= 1
成员变量必须在__init__()中定义,在其他成员方法中引用使用self.x
在外部引用使用X.x
class Car:
def __init__(self,a):
print(a)
self.t = 1
print(self.t)
def printf(self):
print("qaq")
self.t = 1
成员方法
成员方法就直接调用即可了
class Car:
def __init__(self,a):
print(a)
self.t = 1
print(self.t)
def printf(self):
print("qaq")
self.t = 1
a =Car(1)
print(a.t)
a.printf()
继承
继承的方法如下
class QAQ (Car):
pass
可以进行多重继承
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
私有变量
直接的私有private的方法在Python中并不存在,但是我们一般定义__开头的即为私有变量或者私有方法
- 私有变量不能在类的外部被调用,否则会报错
- 私有变量和成员变量一样，要在__init__中定义,才能被成员方法运用
class Car:
def __init__(self,a):
print(a)
self.t = 1
b = 2
self.__qaq=2
print(self.t)
