学渣的整理笔记

CMD控制台上的PYTHON操作

e: \进E盘

变量：在程序中用于保存和表示数据的占位符号

cd 文件夹名 \进入指定文件夹名的文件夹

python 文件名 \以python模式打开指定文件

关于中文的操作

# -- coding: utf-8 -- \UTF-8编写, 在计算机内存中统一用unicode编码,当需要保存到硬盘或者需要传输的时候就转换为UTF-8编码,尽可能节省存储空间

关于缩进的一些操作

缩进是表达语句从属关系的表示方式
当即将缩进时，缩进行之前的语句末尾需要加一个： （冒号）
续行符 是一个 \ 要求有两个。1：续行符之后不能存在空格2：要求立即换行

关于print()操作的一些小问题

print()函数执行后，末尾默认跟一个\n 也就是输出数据后自动换行

在Python中除法的用法

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
9 / 3
3.0
还有一种除法是//，称为地板除，两个整数的除法仍然是整数：
10 // 3
3

格式化输出的方法

方法一：

Python中，采用的格式化方式和C语言是一致的，用%实现，举例如下：
>>> ‘Hello, %s’ % ‘world’
‘Hello, world’
>>> ‘Hi, %s, you have $%d.’ % (‘Michael’, 1000000)
‘Hi, Michael, you have $1000000.’
你可能猜到了，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
常见的占位符有：
占位符　替换内容
%d　　　整数
%f 　　　浮点数
%s　　　字符串
%x　　　十六进制整数

方法二：

print(‘这是变量{ }的输出’.format(Echo))
字符串和变量混合输出

echo=’A’

保留字 in： 成员判断
print(f in [‘F’,’f’]) 返回 true false

eval() 评估函数
去掉参数最外侧的引号并执行引号内的内容返回结果
print(eval(‘1+2’))
结果返回 3

列表操作

可变list L=[ ] \中括号,用单引号或双引号 ，C语言中单引号括一个字符 ，双引号括俩字符。
list插入数据用函数 L.append(x) \注意插入字符带单引号（或者双引号）
extend( )一个参数，参数是一个列表 extend( [ ] )
insert( , )俩参数，一个是位置索引，一个是待插入数据
remove( ) 一个参数，是待删除的数据内容
del 这是个语句，不是函数，也不是方法 故不需要括号，del L[1] del L 直接删除列表L
pop() 出栈，不带参数，默认弹出列表最后一个元素，参数填写索引值，弹出相应元素
count() 计算某个元素在列表中的出现次数
index() 返回某个元素的索引值
reverse() 将列表序列颠倒
sort() 将列表按从小到大排序
list2= list[:] 作用是复制一个跟list一摸一样的列表

元组操作

不可变tuple L=（ ）\用小括号,若要表示一个元素的tuple(元组),例:L=(1,) 加逗号为了区别数学意义的1。
代表是一个不变组中仅有一个元素.关键是逗号，即便没有小括号但似乎有逗号，也是元组 L=1，2，3
可以用拼接操作符 + 间接的去改变一个元组
重复操作符 *

字典操作

dict 用{ }花括号 可以将元素一一对应起来例如名字对应成绩
例: L={ ’ Li ’ :100 , }
定义的时候用花括号 取用的时候用中括号例如 L[‘Li’]
‘Tom’ in L 判断list 中存不存在Tom
L . get(''Tom) 判断list 中存不存在Tom
L . pop(‘Tom’) 删除一个key
L.fromkeys( a,[b ] ) a是索引，b是要对应的value
L.keys( )
L.values()
L.items()
如果建立了一个字典，要求访问必须有一个返回值，可以用L.get( a, [ b ]) #a是其中的一个key
这样，如果访问了一个不存在的值，则会默认返回一个 None,b是自定义如果不存在的返回值
L.clear() 清空 1
字典更新字典的方法
update() b={‘小白’:’狗’}
a.update(b) a是一个已经创建了的字典，并且也有key值 小白，那么对a用update（b）就会将b的value更新到a中与b对应的key的value中
add()
remove()

set 特殊的不重复元组

set 是一组 dict 中 key 的集合,key是不能重复的集合
s=set([1,2,3]) set中是一个list[ ]
s.add(key) 在set中添加一个key
s.remove(key) 在set中删除一个key
set 是无序且无重复元素的集合 可以做交 并集操作
s1=set([1,2,3])
s2=set([3,4,5])
s1&s2
s1|s2

input操作

s=input( ) \默认input接收的为字符串,如果想接收数字则需要类型转换,interger=int(s)

注释操作

选中所有要注释的行 ctrl+/ 一键注释 #单行注释

字符串不可变

字符串是不变的,LIST[ ]是可变的
a=“abc”
a.replace(‘a’,''A)
print(a)
>>>abc
原理是replace新创建了一个字符串"Abc",如果用b=a.replace(‘a’,‘A’),在输出b则是"Abc"

汉诺塔理解递归的神奇之处

/// 汉诺塔递归问题的思想从 N=3时开始，就开始使用递归思想了，套用N=2时的大思路
首先，我们考虑n为1的情况，也即仅有A柱有一个圆盘的情况： 此时我们只需要做到将A柱上的圆盘移动到C柱上即可，我们用下面这条语句来表示这个过程，这就是我们的递归基础；

n == 1
print(a, ‘–>’, c)

其次，我们来考虑n为2的情况，这个时候A柱上从上到下有一小一大两个圆盘，我们需要做的是先借助C柱，将小盘移动到B柱，然后就回到了n为1的情况了，这时我们只需要和之前一样，将A柱上的

圆盘移动到C柱上即可，移动的过程如下：

n == 2
a -> b
a -> c
b -> c
下面，我们来思考n为3的情况，这个时候A柱上从上到下有小中大三个圆盘，从这个时候开始我们要引入抽象的概念，将小盘和中盘视作一个整体，我们现在所需要的是将这个整体借助C柱，移动到B柱上，然后我们就有一次回到了n为1的情况了，本次移动过程如下：

n == 3
a --> c
a --> b
c --> b
a --> c
b --> a
b --> c
a --> c

大家可以发现，当n为3时，步骤以及比较多了，但还是可以用大脑（或手和笔）去跟踪函数运行每一步的执行的，但当n更大时呢（比如5）:

n == 5
a --> c
a --> b
c --> b
a --> c
b --> a
b --> c
a --> c
a --> b
c --> b
c --> a
b --> a
c --> b
a --> c
a --> b
c --> b
a --> c
b --> a
b --> c
a --> c
b --> a
c --> b
c --> a
b --> a
b --> c
a --> c
a --> b
c --> b
a --> c
b --> a
b --> c
a --> c
如果我们继续用大脑（或手和笔）去跟踪函数运行每一步的执行，我们很难保证一步不错地跟下来。

汉诺塔（递归问题）的关键就在于放弃我们让大脑（或用手和笔）去跟踪函数运行每一步的执行的习惯，利用用抽象和自动化的思想解决问题。

事实上，我们总能将A柱最底层的圆盘上面的n-1个圆盘抽象为一个整体，然后借助C柱将其转移到B柱上，然后我们就回归到了n为1的情况了，这时我们只需要和之前一样，将A柱上的一个圆盘移动到C柱上即可；然后，对于此时在B柱上的n-1个圆盘，我们又可以将最底层的圆盘上面的n-2个圆盘抽象为一个整体，借助C柱将其移动到A柱，然后将最底层的圆盘从B柱移动的C柱上，这个时候，那n-2个圆盘又可以继续如上操作；综上所述，我们顺着这个思路，可以发现，我们总有办法将初始柱上的n-1个圆盘，借助目的柱而移动到中间柱上，进而我们就回到了最简单的n为1的情况。

最后，我们来看一下完整的程序

\# -*- coding: utf-8 -*-

def hanoi(n, a, b, c):

     当n为1时 (递归基础)
    if n == 1:
        print(a, '-->', c) # 将A柱最底层的圆盘移动到C柱

    # 当n大于1时
    else:
        hanoi(n-1, a, c, b) # 借助C柱，将n-1个圆盘从A柱移动到B柱
        print(a, '-->', c) # 将A柱最底层的圆盘移动到C柱
        hanoi(n-1, b, a, c) # 借助A柱，将n-1个圆盘从B柱移动到C柱

#调用hanoi函数，这里设置了n为5的情况
hanoi(5, 'a', 'b', 'c')

内嵌和闭包

函数的内嵌和闭包概念：

def Fun1():
	x=5
	def Fun2():
		x=x*x
	return x
return Fun2()
#这里函数中定义了函数，叫做函数的内嵌，闭包就是，凡是定义在函数内部的变量，都是局部变量，例如此时的x=5，
#这样如果在调用Fun2()时，Fun2()会认为x没又定义，因为定义在了Fun1()内部，故x*x 的表达式无法实现，
#可以使用nonlocal关键字进行改进
def Fun1():
	x=5
	def Fun2():
		nonlocal x
		x=x*x
		return x
	return Fun2()

此时，Fun2()就会知道x有一个初值5

函数内部用局部变量在内嵌函数中使用用nonlocal
函数的局部变量在全局使用，用global

文件操作

文件操作
r 只读方式打开（默认）
w 以写入方式打开文件，会覆盖已经存在的文件
x 如果文件已经存在，用此模式打开会引发异常
a 写入，在文件末尾写入，比如想继续写一个文件，直接以此方式打开
b 二进制打开
t 文本模式打开
+ 可读写模式（可以添加到其他模式中）
U 通用换行符支持

close() 关闭
read( size ) 读取size个字符，不给size赋值或size 是负值时，读取全部字符
readline( ) 写入模式打开，若果文件存在，文件指针移至末尾
write( str ) 将字符串 str写入到文件中
writeline(seq) seq是一个返回字符串的可迭代对象将seq写入到文件中
seek( offset, from ) offset代表偏移量，from代表起始点
tell( ) 返回文件指针当前的位置

全局变量和局部变量

count=10
def fun():
	global count
	count=5  
	print(count)  #这样做可以改变全局变量countl的值
print(count)
fun()

不然系统会建立一个局部变量等于全局变量的值
结果是
10
10
当添加global count 后，打印结果
10
5

逻辑运算符

not>and>or 要求越严格优先级越高