Python集训笔记

发表于 | 分类于 | |

Python

内置对象

对象类型 例子
数字 12，1.2,1+2j
字符串 ‘afds’，”fdsaf’dsf”
列表 [5,3,2,1],[1,[2,’three’],4]
字典 {‘food’:’spam’,’taste’:’yum’}
元组 (1,’spam’,4,’U’)
集·合 set(‘abc’),{‘a’,’b’,’c’}
布尔型 True，False
None None
## 空值None
  1. 用来语法占位
  2. 变量解除锁定

表达式

1+2*3

运算符

运算符 释义
+ 加法
- 减法
* 乘法
/ 除法
// 整除、地板除
% 取余
** 幂运算
is/is not 判定是否为同一对象
复合运算符 进行复合合运算
比较运算符 >、<、==、!=< td="">
(不可以使用<>或><)< td="">
遵守数学运算优先级。
START

基本输出函数

格式：
print(‘哈罗世界！’)

事例：

  • print(1+2*3)
  • print(‘asfas”)
  • print(1+2,3+4,100)
  • a=10 print(a)

变量

定义：

关联一个对象的标识符（符号）。

作用：

用来绑定一个数据对象，以便以后重复使用。

命名方法：

  1. 必须为字母或下划线开头，可由字母、下划线、数字组成
  2. 不能使用python关键字（保留字）
  3. 区分大小写

赋值语句 statement

符号： =

语法：

  • 变量名 = 表达式
  • 变量名1 = 变量名2 = 表达式
  • 变量名1,变量名2,…… = 序列

作用：

用于将一个变量绑定在一个对象上

说明：

  1. 当变量不存在时，创建该变量，并绑定此变量
  2. 当变量存在时，改变此变量的绑定关系
  3. 一个变量只能绑定一个对象
  4. 两个变量可以同时绑定同一个对象
  5. 等号可以理解为：赋值、引用、指针

示例：

1
2
3
4
import math
r=3
print('C=',2*r*math.pi)
print('S=',r**2*math.pi)

交换变量：

a,b = b,a

函数

id(x)

返回一个对象在内存中的地址

del 变量名

删除变量同时解除与对象的关联关系

自动化内存管理和引用计数：

每个对象都会记录有几个变量引用自身，当引用的数量为零的时候，此对象将被销毁

complex(a,b)

(a+bj）

bool(x)

x=0或x空时，返回False，其他情况返回True

int(x) float(x)……

转换变量类型

abs(x)

取绝对值

round(数值[,精确值])

四舍五入，保留位数

help()

查看函数帮助

语句 statements

  • a = 10
  • del a
  • print(100)

    语句时python执行的最小单位，语句可以独立执行

说明：

多条语句写在一行内需要用分号分开
通常一条语句写作一行内

折行符 \

折行符是告诉解释执行器，下一行的语句也是此语句的内容

隐式换行：

所有的括号里内容换行时，解释执行器会自动去下一行找到对应的括号，
直到找到为止，称作隐式换行

基本输入输出函数：

输入函数：input

作用：

从标准输入设备上读取一个字符串

a = int(input())

(注：末尾换行符会被删除)

格式：

input（’提示字符串’）

注：返回一个字符串，提示字符串可以为空z
输出函数 print()

作用：

将一系列的值以字符的形式输出到标准设备上，默认为终端

格式：

print(value, … ,sep=’ ’,end=’\n’)

关键字参数说明：

sep:两个值之间的分隔符，默认为一个空格’ ‘

end:输出完毕后在流末尾自动追加一个字符串，默认为换行符’\n’

if 语句

作用：

让程序根据条件选择性的执行某条语句或某些语句

语法：


If 真值表达式1：
    语句块1…
elif 真值表达式2：
    语句块2…
    …
else:
    语句块n…

说明：

  1. 真值判断会自上而下进行，如果有一条为true则执行其中的语句块，
    然后结束if语句的执行，如果所有真值表达式都为False，则执行else子句里的语句
  2. elif子句可以有0个，1个或多个
  3. else子句可以有0个，或1个

DAY2

if语句的嵌套

if语句本身是由多条子句组成的一条复合语句

if语句可以作为语句嵌套到另一个语句的内部

练习：写一个程序，输入一个数，用if语句计算并打印这个数的绝对值

注：不能用abs语句


A = int(input('请输入一个数'))
if A < 0:
    print(-A)
else:
    print(A)


A = int(input('请输入一个数'))
if A < 0:
    A = -A
print(A)

条件表达式

语法：

表达式1 if真值表达式 else 表达式2

作用：

如果真值表达式的布尔值为True时，则执行表达式1，并返回结果对象的引用，否者表达式2，并返回对象引用。

例子：

商场促销，满100减20


money = int(input('请输入商品金额：'))
pay = money - 20 if money >= 100 else money
print('您需要支付：',pay,'元')

练习：输入一个数，用条件表达式计算并打印这个数的绝对值。


n = int(input('请输入一个数：'))
print(n if n > 0 else - n)

pass语句

作用：通常用来填充语法空白

  • def fun（）：
  • pass
  • fun ()

布尔运算：

运算符： not and or

布尔非操作 not

not x

作用：对X进行布尔非取值，如bool(x)为True则返回False，否则返回True

布尔操作and

x and y

表达式 结果
True and True # True
True and False # False
False and False # False
False and False # False 
1
2
if  1<= x="" <="12:" #if="" 1<="x" and="">
	print("合法月份")

布尔或运算 or

x or y # 等同于 x if bool(x)==True else y

思考： S = input(‘请输入学生的成绩：’) or ‘0’

  • bool(‘’)
  • bool([])

正负号运算符

正负号运算符式一元运算符（只有一个元素参与）

  • a = 5
  • b = -a
  • d = (2 - 3j)
  • e = -d #(-2+3j)

调用库

  • import math
  • math.pi
  • math.sqrt(81)

随机整数

  • import random
  • random.randint(0,100)
  • random,choice([1,2,3,9]) #从固定数组中抽取

S = 'Spam'
len(s)
S[0]
S[1]
S[4]
切片：
S[1:3]
S + 'xyz'
=>Spamxyz

L[ : : -1]

#[起始：终止：步长]

L.append(‘OK’)

将ok添加到L表中

L.pop(2)

弹出表中相应位置元素 （）为空弹出最后一个

M.sort

对M表格排正序

M.reverse（）

对表格排倒序

L[1] = L [:]

L[:]是L的拷贝

循环语句

for循环:

1
2
3
for .... in .....:
	语句块
`
1
2
3
names = ['zhang','wang','li']
for name in names:
	print(name)
1
2
3
4
sum = 0
for x in [1,2,3,4,5,6,7]:
	sum += x
print(sum)

range()函数

1
2
3
4
range(10)
=>range(0,10)
list(range(10))
从零到九
1
2
for x in range(10,20,2):    #起始，终止，步长
	print（x）
1
2
3
d = {'a':3,'b':4,'c':5}  #字典
for i in d:
	print(i)
1
2
for i in d.keys():     #键
	print(i)
1
2
for i in d.valuse():  #值
	print（i）
1
2
for k,v in d.items():    #同时迭代key和valuse
	print(k,v)

循环嵌套

1
2
3
4
for i in range(10,31,10):
	print(i)
	for j in range(3):
		print(j)

while循环：

1
2
3
4
5
6
sum = 0
n = 99 
while n > 0:
	sum = sum - n
	n = n - 2
print(sum)
1
2
3
4
5
6
7
n = 1
while n < = 100:
	if n > 10:
		break   # break语句会终止循环
	print(n)
	n = n + 1
print('end')
1
2
3
4
5
6
n = 0
while n < 10 :
	n = n + 1
	if n % 2 == 0:
		continue   #跳过本次循环，继续执行下一次循环
	print(n)

用循环生成列表

1
2
3
4
5
6
L = []
n = 1
while n <= 29:
	L.append(n)
	n = n + 2
print(L)

列表解析：（列表推导式，列表生成式）

1
2
J = [x*2 for x in range(1,30,2)]
print(J)
1
2
3
4
5
6
7
N = [[1,2,3],[4,5,6],[7,8,9]]
col2 = [row[1] + 10 for row in N]
print(col2)


col2 = [row[1] + 10 for row in N if row[1] % 2 == 0]
print(col2)
1
2
doubles = [c *2 for c in 'spam']
print(doubles)

案例：

1
2
3
4
5
6
7
8
9
y = int(input('please input a mnumber:'))
x = y // 2
while x > 1:
	if y % x == 0:
	print(y,'has factor',x)
	break
x -= 1
else:      #当循环正常终止时（非break），执行else语句块
	print(y,'is prime')

求出100以内所有质数，用for循环来写

1
2
3
4
5
6
7
8
9
10
11
end = int(input('输入数:'))
zhishu = []

for n in range(2,end + 1):
    for m in range(2 , n):
        if n % m == 0:
            break
    else:
        zhishu.append(n)
print('计算结果是：')
print(zhishu)

优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
end = int(input('输入数:'))
zhishu = []

for n in range(2,end + 1):
    for m in range(2 , n):
        if m ** 2 > n:
            zhishu.append(n)
            break
        if n % m == 0:
            break
    else:
        zhishu.append(n)
print('计算结果是：')
print(zhishu)

DAY3

1
2
3
N = [[1,2,3],[4,5,6],[7,8,9]]
M = [x[y] for x in N for y in range(3)]
print(M)

列表推到式求出100以内质数

1
2
3
4
[x for x in range (2,101) if True]
[x for x in range (2,101) if [y for y in range (2,x) if x % y != 0]]   #错，不充分
[x for x in range (2,101) if not Flase]
[x for x in range (2,101) if not [y for y in range (2,x) if x % y == 0]]

假如有一个列表中有很多数据，里面有重复的数据，例如：L：[9,8,7,6,5,4,3,2,1….]打印出列表中的数据，要求重复的只打印一次，打印的顺序一列表中第一次出现的循序为准。例如上述打印：[9,8,7,6,5,4….]

1
2
3
4
5
6
7
L = [9,8,6,5,6,6,0,4,2,4,9]
result = []

for x in L[:]:
	if x not in result:      # not
		resust.append(x)
print(result)

斐波那契数列：

1,1,2,3,5,8,13,21,34,…..
求前40个数

1
2
3
4
5
6
7
8
9
10
fibs = [1,1]
a = 1
b = 1

while len(fibs) < 40:
	f = a + b
	a = b
	b = f
	fibs.appeds(f)
print(fibs)

法2 ：

1
2
3
4
fibs = [1,1]
while len(fibs) < 40 :
	fibs.append(fibs[-2] + fibs[-1])
print(fibs)

练习：编写程序，计算并打印数列前20项之和：
2/1,3/2,5/3,8/5,13/8,21/13 …

1
2
3
4
5
6
fibs = [1, 2]
s = []
for x in range(20):                     #range(20) -> range(0,20)
	s.append(fibs[-1]/fibs[-2])
	fibs.append(fibs[-2] + fibs[-1])
print(sum(s))

函数

函数的语法：

1
2
3
def 函数名(参数列表)：
	“函数文档字符串”
	函数语句块

函数的作用：

  • 定义用户的函数
  • 函数是可以重复执行的代码块，可以重复使用
  • 函数的名字就是代码块的名字
  • 函数的名字是一个变量(不要轻易对其赋值)
  • 函数有自己的命名空间，不要让函数处理的外部的数据需要使用参数传入

函数的调用

函数名(实际参数)

return 语句

语法：

1
2
3
return 表达
或
return             #默认 return None

作用：

结束当前函数的执行，返回到调用函数的地方，同时返回一个值对象的引用

1
2
3
4
5
6
7
8
9
def mymax(a1, a2):
	m = a1
	if a2 > m:
		m = a2
	return m

x = 100
y = 200
print(mymax(x,y))

位置参数

实际参数的对应关系与形式参数的对应关系是以位置来一次对应的

说明：位置参数，形式参数的个数必须与实际参数的个数相同

练习：写出一个求最小值的函数，包含三个参数，返回最小值

1
2
3
4
5
6
7
8
9
10
def mymin (x,y,z):
	if x < y:
		min = x
	if min > z:
		min = z
	return min
x = int(input('please input x:'))
y = int(input('please input y:'))
z = int(input('please input z:'))
print(mymin(x,y,z))

写一个函数isprime(x)判断x是否为质数，如果为质数，返回True，否者返回Flase

1
2
3
4
5
6
7
8
9
10
def isprime(x):
	for i in range(2,x + 1)
		if i ** 2 > x:
			return Ture
			break
		if n % i == 0:
			return False
	return False             #防止负数
x = int(input('please input x:'))
print(isprime(x))

写一个函数prime_m2n(m,n)，返回从m开始，到n结束范围内的质数，并返回这些质数列表，并打印：

1
2
3
4
5
6
7
8
9
10
def prime_m2n(m,n):
	prime_num = []
	for i in range(m,n+1):
		if isprime(i):
			prime_num.append(i)
	return prime_num

m = int(input('please input m:'))
n = int(input('please input n:'))
print(prime_m2n(m,n))

练习：利用切片操作实现一个 trim()函数，去除字符串首尾的空格，注意不要调用str的strip()的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def trim(s):
	for i in s[:]:
		if i == ' ':
			s = s[1:]
		else:
			break
	for i in s[::-1]:
		if i == ' ':
			s = s[:-1]
		else:
			break
	retutn s
a = '    hello  word    '
print(trim(a))
if trim(a) == 'hello word':
	print('测试成功')

面向对象编程（oop）

  • oop 是为了代码重用
  • 可以用一个类来产生多个实例对象
  • 什么是面向对象：一切皆对象，对象和对象之间有关联关系
  • 图纸 -> 类class
  • 具体的某辆车 -> 对象(object)/实例(insyance)
  • 人(类) -> 张三(实例对象) #想要创建实例对象，先要创建类

类的创建语法：

1
2
3
4
5
[@类装饰器]
class 类名(继承列表)：
	“类文件字符串”
	实例方法 （内类的函数方法叫method）定义
	类变量定义

最简单的类：

1
2
class DOg:
	pass

类的作用：

  1. 定义一个类，可以用来创建实例对象

  2. 类内定义的变量和方法能被比此类所创建的实例所共同拥有

  3. 类通常用来创建具有共同属性的对象

    （如果只是创建了一个对象，用模块就可以，不必用类）

实例创建表达式：

实例名 = 类名(创建传参)

作用：

创建一个类的实例对象并返回此实例

实例说明：

  1. 实例有自己的作用域和名字空间，可以为该实例添加变量(实例变量/实例属性)
  2. 实例可以调用类的方法
  3. 实例可以间接的访问类中的变量

实例变量的调用语法：

实例.变量名

点在模块中的用法：

  • 模块.变量名
  • 模块.函数名
  • 模块.类名

实例变量的赋值规则：

  1. 首次赋值则创建实例变量
  2. 再次赋值则改变实例变量的绑定关系

实例的方法：

语法：

1
2
3
4
5
class 类名（传承列表）:
	def 实例方法名(self,参数1，参数2...):
	"文档字符串"
	语句块
(self是指实例自己)

实例方法的调用语法：

  • 实例.实例方法名(调用参数) #常用方法

或

  • 类名.实例方法名(实例，调用参数)

说明:

  1. 实例方法的实质就是函数，是定义在类内的函数
  2. 实例方法属于类属性
  3. 实例方法的第一个参数代表调用这个方法的实例，一般命名为‘self‘
  4. 实例方法如果没有 return 语句，则返回 none

    例子：dog.py

#DAY4

构造方法:

作用：

创建对象时初始化实例变量:

(建立给每个对象传参共同方式，及初始化对象的属性)

语法：

def inint (self [,参数列表]):

语句块

说明：

  • 构造方法必须为int,不可改变
  • 在一个类中只能有一个_int_构造方法（有多个时，最后一个起作用）
  • 构造方法会在实例生成式自动调用，且将实例自身通过第一个参数self 传入 int方法
  • 构造方法如果没有return语句，则返回self本身。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class car:
    def __init__ (self, color, brand, model):
        self.brand = brand
        self.model = model
        self.color = color

    def run(self, speed):
        print(self.color, self.brand, self.model,\
            '正在以', speed, 'KM/h速度行驶')
        t = (self.color, self.brand, self.model, speed)
        fmt = '%s%s%s正在以%dkm/h行驶' %t    #格式化字符串

    def change_color(self, c):
        self.color = c

    def infos(self):
        print('车辆信息为：', self.brand, self.model, self.color)

a4 = car('红色','奥迪','A4')
a4.run(199)
a4.change_color('黑色')
a4.run(230)
a4.infos()
print(a4.color)

在oop程序设计当中，当我们定义一个class时侯，可以从某个现有的class类继承，新的class称为子类（subclass），而被继承的class称为基类，父类或超类（Base class,Supper class）.子类可以继承父类的方法

比如：我们已经编写了一个名为Animal的class、有一个run（）的方法可以直接打印：

1
2
3
4
5
class Animal(object):
	def run(self):
		print('Animal is running')
a = Animal()
a.run

当我们需要编写Dog类和Cat类时，就可以之接从Animsl类继承

1
2
3
4
5
6
7
8
9
class Dog(Animal):
	def run(self):
		print('Dog is running....')

	def Cat(self):
		print('Eating meat....')

Class Cat(Animal):
	pss

对于Dog类来说，Animal就是父类，对于Animal来说，Dog就是他是子类。Cat类和Dog类同理。

继承有什么好处？

做大的好处就是子类获得了父类的全部功能。由于Animal实现了run()方法，因此，Dog和Cat作为他的子类，即使没什么事干，它自动拥有了run()的方法。

1
2
3
4
5
Dog = Dog()
dog.run()

cat = Cat()
cat.run()

当子类和父类都在相同的run()方法时，我们说，子类的run()覆盖了父类的run(),在代码运行的时候，总是会调用子类的run().这样，我们就获得了继承的另一个好处：多态。

在继承关系中，如果只是一个实例的数据类型是某个子类，呢么他的数据类型也可以被看作是父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Human:
	def say(self, what):
		print('say:', what)
	
	def run(self, speed):
		print('run....', speed)

class Student(Human):
	def study(self, program):
		print('learing', program)

h1 = human()
h1.run(5)
h1.say('good weather!')

s1 = Student()
s1.run(10)
s1.say('good', day)
s1.study('python')

class Teacher(human):
	def teach(self, language):
		print('teaching', language)

t1 = Teacher()
t1.run(6)
t1.say('home work is')
t1.teach('python')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Bicycle:
	def Run(self, Km):
	print('自行车骑行了'. km, '公里')

class EBicycle(Bicycle):
	def __init__ (self, vol):
	self.max_volume = vol
	self.cur_voume = vol

# 每骑行10km消耗电量1度， 同时显示当前电量
	def Run (self, KM):
		v = min(KM/10,self.cur_volume) # min(), 求参数中最小值
		self.cur_volume -= v
		print('电动车骑行了%d km' % (v*10))
		print('电动车剩余电量：'， self.cur_volume)

def fillcharge(self):
	print('正在充电')
	self，cur_volume = self.max_volume

b = EBicycle(5)
b.Run(10)
b.Run(1000)
b.fillcharge()

封装

封装指隐藏类的实现细节，让使用者不关心这些细节

python的封装是假的（模拟的）封装

python以双下划线开头，不以下划线结尾的实例变量为类的私有变量，在子类中无法使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Father:
	def __init__(self):
		print('A::__init__')
		self.__money = 10000

	def makemoney(self,m):
		self.__money += m

	def moneys(self):
		print(self.__money)
class B(Father):
	def __init__(self):
		super() .__init__()
	def show_money(self):
		# print(self.__money)
		print(self._Father__money)

b = B()
b.makemoney(2000)
b.moneys()
b.show_money()

模块

什么是模块：

模块是一个包含1个或多个函数，变量，类等组成的程序组
模块文件通常以.py结尾

模块的作用：

1.让一些相关的变量，函数，类等有逻辑的组织在一起
2.让逻辑解构更加清晰
3.模块中的函数和类等可提供给其他模块或程序使用

模块的分类：

1.内置模块（builtins）,在解析器内部可以直接使用
2.标准库模块，python安装时已经标配
3.第三方模块（通常为开源），需要自己安装
4.用户自己编写的模块（也可以作为其他人的第三方模块）

为什么使用模块

1.代码复用
2.系统命名空间的划分(避免变量冲突)
3.实现共享服务和共享数据（一个模块被多个函数或文件导入）

如何组织一个程序：

1.一个python程序包含了多个含有python语句的文本文件。顶层文件和多个支持文件构成
2.顶层文件（又被称脚本）包含了程序的主要控制流程（启动应用的文件）
3.模块文件就是工具的库，顶层文件使用模块文件中定义的工具，而这些模块使用了其他模块所定义的工具
4.在python中，一个文件导入了一个模块来获得这个模块定义的工具的访问权，这些工具被认作是这个模块的属性。

模块的导入:

import 模块名1 [as 模块新名1][, 模块名2]

import 模块名

import 模块名 as 新名

1
2
3
4
import math
print(math.sqrt(9))

math = 2.7   ####不要用模块当变量名
1
2
import math as m
print(m.factorial(5))   ##阶乘
1
2
3
4
5
6
7
8
9
10
11
12
13
from 模块名 import 模块属性 as 新名
(这种方法导入后，可直接使用模块中的属性，不需要再写模块名)

from 模块名 import *

from math import factorial as fac
print(fac(5))

from math import pi
print(pi)
print(sin(pi/2))

from math import *

数学模块 math:

变量：
变量 含义
math.e 自然对数
math.pi 圆周率
##### 函数：
函数 含义
— —
math.floor(x) 对x向下取整 x=1.2 返回1
math.ceil(x) 对x向上取整 x=1.2 返回2
math.sqrt(x) 返回x的平方根
math.factorial(x) 求x的阶乘
math.log(x[,base]) 放回以base为底的对数，如果不给出base则以e为底
math.log10(x) 求10为底的对数
math.pow(x,y) 返回x**y
math.fabs(x) 返回浮点数x的绝对值
math.degress(x) 将弧度转换为角度
math.radians(x) 将角度转换为弧度
math.sin(x) x正弦
math.cos(x) x的余弦
math.tan(x) x的正切
math.asin(x) 返回x的反正弦
math.acos(x) 返回x的反余弦
math.atan(x) 返回x的反正切

时间模块 time

使用方法：

1
2
3
4
5
6
7
8
9
10
11
12
import time
from time import *
from time import sleep

time.sleep(seconds)

from time import *
L = [1,2,3]
for i in L:
	L.append(L)
	sleep(L)
	print(L)

多次导入一个模块时，模块对应的.py文件不会多次执行

模块只执行一次,py程序

模块路径的搜索顺序：

1
2
3
4
5
6
import  模块名  #去哪找这个模块
1.搜索内置模块（用c语言写的内置在python程序中的模块，无法用路径找到）
2.标准库路径（如：sys, os）
3.sys.path提供的路径
  sys.path是一个表，里面放的都是模块搜索路径
4.搜索程序运行的路径（当前路径）
  • import dir.dir2..mod (dir0\dir1\dir2\mod,py)
  1. dir1和dir2中必须都含有一个init.py文件
  2. dir0是容器，不需要init.py文件，如果有的话，这个文件会被忽略
  3. dir0必须列在模块的搜索路径上（也就是此目录必须为主目录，或者在PYTHONPATH中）
  • init.py可以包含python程序代码（比如print语句），也可以完全是空的。作为一个高级功能，可以在init.py文件中使用all列表来定义目录，
  • 当以from … import * 导入时，来定义需要导入什么。
  • all = [‘super’,’tank’,’contra’]

某次战役中，为方便信息交互，我军侦察部门将此次的关键高地坐标设定为（x = 0,y = 0），并规定，没向东增加100米，x加1，向北增加100米，y加一，同时我军情报部门也破译了敌军向坦克发送的指挥信号，其中有三种信号（L,R,M）用于控制坦克运动，L和R分别表示向左、向右转向，M标识零坦克前进100米，其他信号如T时间同步，P用于位置校准（T，P不会控制坦克移动）

一日我军侦察兵发现了敌军的一辆坦克，侦察兵立即将坦克的坐标（P，Q）及坦克前进方向（W，E，N，S）发送给指挥部，同时启动信号接收器，将坦克接受的信号实时同步发往指挥部，指挥部用过信息计算出坦克位置，并击毁该坦克

  • 请设计程序计算出坦克所在位置。

  • （P=11，Q=39） 初始朝向：W

  • infor = ‘MTMPRPMTMLMRPMTPLMMTLMRRMP’

  • L = [1,2,3,4,5]

  • i = L.index(3) # 查找索引

  • print（i） # 2

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    direction = 'W'
    p = 11
    q = 39
    infor = 'MTMPRPMTMLMRPMTPLMMTLMRRMP'
    def cal_direction(turn):
    	D = ['E', 'S', 'W', 'N']
    	i = D.index(direction)
    	if turn == 'L':
    		i = i - 1
    	if turn == 'R':
    		i = i + 1
    	if i == len(D):
    		i = 0
    	return D[i]

    def cal_move(p,q):
    	if direction == 'E':
    		p = p + 1
    	elif direction == 'N':
    		q = q + 1
    	elif direction == 'W':
    		p = p - 1
    	elif direction == 'S':
    		q = q - 1
    	return p, q
    for i in infor
    	if i == 'L' or i == 'R':
    		direction = cal_direction
    	if i == 'M':
    		p,q = cal_move(p,q)

    print((p,q),direction)

DAY5

飞机大战游戏

设计思路：

1.游戏中的几种对象？

  • 敌机 蜜蜂 子弹 战机

2.考虑游戏有几种状态？

  • 开始 运行 游戏结束

3.考虑敌机怎么移动？英雄机怎么移动？蜜蜂子弹怎么移动？

  • 敌机下降（y坐标+）
  • 战机：随鼠标移动（鼠标在图片中心）
  • 子弹：直线上升，从战机所在位置发出
  • 蜜蜂：先向右下，到右边界之后转向左下

游戏组成：

1.窗体 面板 子弹 敌机 战机 蜜蜂

2.自己的飞机和敌人的飞机

3.飞机动起来

4.互相打

业务需求：

1.打死敌机+5分

2.打死蜜蜂：奖励生命值或双倍火力

3.战机和敌机碰撞后：生命-1

4.双倍火力：发一次子弹双倍火力子弹-2

设计模型：

1.战机，敌机，蜜蜂，子弹，分数，生命值，都是矩形框

2.坐标：以矩形框的左上角为依据

让tkinter GUI 程序启动和运行起来需要五个步骤

1.导入tkinter模块

import tkinter

2.创建一个空白窗口对象，用于容纳整个GUI应用

3.在空白窗口对象上构建所有的GUI组件及功能

4.通过底层的应用代码将这些GUI组件间接起来

5.进入主事件循环

DAY3

请写一段python代码实现删除一个list里面重复的元素

1
2
L = [1,2,2,7,3,5,7,5,3,2]
print(list(set(L)))     # 因为集合是无序的

不需使用set

1
2
3
4
5
6
7
8
9
L3 = []
j = 0

for i in L:
	if i not inL[:j]:
		L3.append(i)
	j = j + 1

print(L3,'L3')

python里如何拷贝一个对象？（赋值，浅拷贝，深拷贝的区别）

  • a = 3
  • b = a

浅拷贝（copy）：拷贝父对象，不会拷贝对象内部的子对象

1
2
3
4
5
6
a = {1:[,2,3]}
b = a.cpopy()
print(b)
a[1].append(4)
print(a)
print(b)

深拷贝（deecopy）:copy模块的deepcopy方法，完全拷贝了父对象及其子对象

1
2
3
4
5
6
import copy
c = copy.deepcopy(a)
print(a,c)
a[1].append(5)
print('a',a)
print('c',c)

二分查找

必须是有序的数列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import random
L = [1,3,5,6,7,12,34,89,99]
guess = L[random.randint(0,len(L)-1)]       # L[]
print(guess)

def dich(L):
	low = 0
	heigh = len(L) - 1
	while low <= heigh:<="" span="">
	mid = (low + heigh)//2
	if L[mid] == guess:
		print('猜对了，是%s' % L [mid])
		return L[mid]
	if L[mid] < guess:
		print('猜小了，%s' % L [mid])
		low = mid + 1
	if L[mid] > guess:
	print('猜大了，%s' % L [mid])
	heigh = mid - 1

快速排序： #递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
L = [5,4,7,3,9,2,10,11,1]
target = 5
	[4,3,2,1,5,7,9,10,11]
	[4,3,2,1][5][7,9,10,11]

L = [5,4,7,3,9,2,10,11,1]

def quickSort(L)
	if len(L) <= 1:<="" span="">
		return L
	else:
		target = L[0]
		smaller = [i for i in L[1:] if i < target]
		bigger = [i for i in L[1:] if i >= target]
		return quickSort(smaller)+[target]+quickSort(bigger)
print(quickSort(L))

三张支票，100万，其中一张是真的，两张是假的。让你选一张，主持人会帮你从剩下的两张中，拿出一张，并告诉你这张是假的。此时，主持人会问你是否坚持原来的选择，还是更换选择。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import random

times = int(input('请输入测试次数：'))
L = [0,1,2]

def guess_ch():
	real = random.randint(0,2)
	L2 = L[:]
	choice_1 = random.randint(0,2)
	for i in L2:
	if i != real and i != choise_1:
		L2.pop(L2.inde(i))
		break
	for i in L2:
		if i != choicd_1:
			if i == real:
				return True
			else:
				return Flase

def guess_notch():
	real = random.randint(0,2)
	L2 = L[:]
	choice_1 = random.randint(0,2)
	if choice_1 == real:
		return True
	else:
		return Flase
right_1 = 0
wrong_1 = 0
right_2 = 0
wrong_2 = 0
for i in range(time):
	if guess_ch():
		right_1 += 1
	else:
		wrong_1 += 1
	if guess_notch():
		right_2 += 1
	else:
		wrong_2 += 1
print('更改选择：')
print('猜正确的次数为%d次'% right_1)
print('正确率：',right_1/times)
print('不更改选择：')
print('猜正确的次数为%d次'% right_2)
print('正确率：',right_2/times)

小白鼠

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import random 

poison_bottle = random.randint(1,1000)
find_bottle = 0

M = {x:[] for x in range(1,11)}

for i in range(1,1001):
	i2 = i
	for j in range(1,11):
	dp = i % 2
	if dp == 1:
		M[j].append(i2)
	i -= dp
	i /= 2

find_bottle = 0
p_b = poison_bottle
dead_mouse = []
for i in range(1,11)
	dp = p_b % 2
	if  dp == 1:
		dead_mouse.insert(0,i)
	p_b -= dp
	p_b /= 2
for n in dead_mouse:
	find_bottle += 2 ** (n-1)

print(poison_bottle)
print(find_bottle)
print(dead_mouse)

for i in
0%