《零基础入门学习Python》第一讲~第二十三讲笔记

小山90

第三节：
teacher=’小山’
print（teacher）

变量可以加减，包括字符串变量；

1使用变量前赋值
2变量名规范与C语言一样
3变量大小写代表不同
4等号赋值
5变量名请尽量专业


字符串：文本，引号’’内的所有内容
python创建字符需要添加引号，单双引号均可，但必须成对
字符串中需要引号，例如 let’s go 。可用转义字符 ‘let\’s  go’ 。另一种方法自行学习。

原始字符串
>>str = ‘C:\now’
>>str
>> ‘C:\now’
>>print(str)
>>C:
>>ow
\n被转义变为换行。此时可以使用原始字符串，即：
>> str = r‘C:\now’    #添加r，变为原始字符串
>>str
>> ‘C:\\now’    #自动添加了转义符
>>print(str)
>>C: \now
但原始字符串最后不能使用\，即r‘C:\now\’这样是错误的
如必须要用，自行学习


长字符串：
多个换行的长字符串，可使用三重引号字符串，可单引号可双引号，但必须连续成对出现

 
第四节
条件分支
If 条件：#有冒号
   真执行的操作  #句首有缩进
Else 条件：
   假执行操作


While循环：程序重复应用某些代码；
While 条件：
   真执行的操作


引入外援
首行引入模块
>>import random
>>secret = random.randint(1,10)
这样可以通过模块生成随机数

 
第五节
Python 的数据类型
“520”字符串  520 数字
字符串相加==字符拼接
数字相加==两数之和

Python 数值类型
整型：整型长整型已结合，长度不限；（Python2  长整型要加l）
浮点型：小数，有小数点即浮点型
E记法：科学计数法，如 1.5e11
布尔类型：特殊的整型，用true（1）和false（0）表示

类型转换
整数：int()   浮点数转换为整数，Python采用去一法
浮点数：float()
字符串：str()

获取变量类型的函数
type(a) 可以获得类型
>>>a = ‘小山’
>>>isinstance(a,str)
返回true，表明两类型匹配；不匹配返回false

 
第六节
Python常用操作符
+ - * /  常用运算符；
其中 a = a+1  等同于 a += 1；同理 -=   *=   /=
// 地板除法，仅保留整数位，小数舍弃
% 取余数；
** 为幂运算操作符，a ** b 即a的b次方；

优先级问题
幂运算符：优先级比左侧高比右侧低  -3 ** 2 返回 -9  9 ** -2 返回 3；

比较操作符

逻辑操作符
Not  取相反的布尔类型值；

优先级问题
从高到底
1、        幂运算
2、        正负号（一元运算符）
3、        乘除，地板除法
4、        加减法
5、        比较操作符：大于小于等
6、        逻辑操作符（not   and   or）


 
第七节
循环是编程的基础，通过判断引导向不同发展；
判断：做不做某事；循环：持续做某事；

打飞机游戏框架：
如果飞机没被撞
   音乐循环播放
   随机位置产生敌对飞机
   敌对飞机匀速向下
被撞了
   音乐变化
   界面停止
   返回固定输出文字

小甲鱼答案：
加载背景乐音
播放背景音乐（设置单曲循环）

我方飞机诞生
Interval = 0 #控制飞机诞生条件
While true：
If 用户是否点击关闭按钮
    退出程序

Interval += 1
If Interval == 50
    Interval = 0
敌对小飞机诞生

小飞机移动一个位置
屏幕刷新

If 用户鼠标产生移动
    我方飞机中心位置 = 用户鼠标位置
    屏幕刷新

If 我放飞机与小飞机发生冲突
    我方挂，播放撞机音乐
    修改我方飞机图案
    打印 gg
    停止背景音乐，最好淡出


 
第八节
条件 elif == elseif
编程时需考虑CPU执行效率

Python可有效避免“悬挂else”
C语言if else采用就近匹配原则，不严格要求缩进；
Python强制使用缩进，避免悬挂

条件表达式（Python唯一的三元操作符）
语法： x if 条件 else y
Small = x if x < y else y

断言（assert）
当关键字assert后条件为假时，程序自动崩溃，并给出assertionerror异常；
一般在测试程序中使用，可在程序中设置检查点，当程序中某条件一定为真才能程序正常工作时，assert非常有用。

&#8195;
第九节
For循环
语法：
For 目标 in 表达式
   循环体

Range（）
是一个BIF函数，也是for循环的小伙伴
语法：
Range([start,]  stop[, step=1])
作用为生成一个从start参数的值开始但stop参数的值结束的数字序列
Step表示步进值

Break 终止当前循环，跳出
Continue 终止本轮循环，开始下一轮循环。循环前会判断条件


&#8195;
第十讲  列表（打了激素的数组）
数组要求所有数据类型一致；
Python加入了列表，各类型数据都可以放入列表（整数，浮点数，字符串，对象）
创建列表
中括号括起来，各成员逗号隔开；
向列表添加元素
>>>member = []
>>>member.append(“哈哈哈”)
属于对象的函数叫做方法，append这种方法数据member对象
但每次append只能添加一个元素

>>>member.extend([“哈哈哈哈”,”呼呼呼”])
方法extend是扩展列表，因此扩展对象也应该是一个列表，需要加[]

>>>member.insert(1,”牡丹”)   #在第1个位置插入牡丹

&#8195;
第十一节：
从列表获取元素
>>>member[0]   #索引从0开始

从列表删除
>>>member.remove(“哈哈哈”)  #删除元素，不需要知道位置
>>> del member[1]   #del是函数，直接删元素，或删除整个列表
>>>member.pop()  #返回最后的一个元素，列表中删除最后一个
>>>member.pop(2)  #删除列表第三个

列表分片：一次性获取多个元素
>>>member[1:3]  #原列表布标，拷贝出来你要的内容
>>>member[1:]   #拷贝从第二个到最后

&#8195;
第十二讲
列表操作符
两列表比较大小，从序号0的数开始比，只要序号0比出结果即结束，雷同字符串

列表可以通过+实现列表拼接，但是+不能加新元素，+号左右类型必须一致
列表可以通过*实现列表复制

成员关系符
>>> list1 = [123,456]
>>> 123 in list1
True
表明在其中，同理 not in 也是成员关系符

列表中的列表值，不能被in发现，因此可知 in 只能影响一层，类似 break
如果要判断列表里面的列表元素
>>> list2 = [123,["small","hill"],456]
>>> "hill" in list2[1]
True

列表类型的内置函数
>>> dir(list)   #可查看列表的内置函数有哪些
count返回某个元素出现的次数
index返回某个元素的索引，也可以返回某个元素在一定范围的索引  index(121,3,7) 索引3到7间，121的位置
reverse让列表反续
sort对列表进行排序，默认从小到大排序；sort(func, key, reverse)  func指定排序方法，key和算法搭配关键字，这两个都是默认的；reverse默认false，若改为reverse=true，则变化；

>>> list2 = list1[:]
>>> list3 = list1
若list1变化，则list3变，list2不变；
因此确实要用拷贝必须要用分片的方式

&#8195;
第十三讲
元组：戴上了枷锁的列表  tuple
元组定义以后，就不可在做任何变化

创建元组：多数通过小括号创建
>>> tuple1 = (1,2,3,4,5,6,7,8,9)
>>> tuple1[4]    #访问用[]
>>> tuple1[:5]   #和列表一样
(1, 2, 3, 4, 5)
>>> tuple2 = tuple1[:]   #拷贝也和列表一样
>>> tuple2
(1, 2, 3, 4, 5, 6, 7, 8, 9)

元组的特征表现关键是逗号
>>> tuple3 = 3,4,6
>>> type(tuple3)
<class 'tuple'>
>>> temp = ()   #创建空元组
>>> type(temp)
<class 'tuple'>

更新和删除元组
>>> temp = ("哈哈哈","啦啦啦","嘿嘿嘿")
>>> temp
('哈哈哈', '啦啦啦', '嘿嘿嘿')
>>> temp = temp[:2]+("啪啪啪",)+temp[2:]   #只能通过切片方式添加
>>> temp
('哈哈哈', '啦啦啦', '啪啪啪', '嘿嘿嘿')

>>> del temp   #删除元组

元组可用操作符：
+ *  切片或者重复
成员操作符  in/not in
关系操作符  >  <
逻辑操作符  and or

&#8195;
第十四讲
字符串：各种奇葩的内置方法
>>> str1 = "I love you"
>>> str1[:6]    #字符串可进行切片
'I love'

字符串类似元组，一经创建很难更改，插入需要通过拼接进行；
变量名实际只是标签，创建的内容在存储里，变量名只是加了一个指向到存储

字符串扩展阅读：字符串的方法及注释
http://bbs.fishc.com/forum.php?m ... peid%26typeid%3D403

&#8195;
第十五讲
字符串格式化
按照统一的规格输出，成为一个字符串
字符串格式化：纠正规范可能出现的问题，2/10/16进制表达不一样
Format 接受位置参数和关键字参数，传到replacement，由{}表示
>>> "{0} love {1}.{2}".format("I","you","com")
'I love you.com'
其中0,1,2是位置参数
>>> "{a} love {b}.{c}".format(a="I",b="you",c="com")
'I love you.com'
其中a,b,c是关键字参数
位置参数和关键字可以混合，但是位置参数必须在最前面，否则报错
打印花括号
>>> "{{0}}".format("haha")
'{0}'
因为0已经被花括号表示，所以不会被替换

>>> "{0:.1f}{1}".format(27.658,"GB")
'27.7GB'
0:.1f   冒号表示格式化符号的开始 .1表示四舍五入一位

格式化符号含义及转义字符含义
http://bbs.fishc.com/forum.php?m ... peid%26typeid%3D403

&#8195;
第十六讲  序列
列表，元组，字符串一起称为序列；
List（）把可迭代对象转换为列表
迭代：重复反馈过程的活动，目的为接近或达到所需的目标或结果，每次目标的重复为一次迭代，每次迭代结果为下一次初始值

Tuple（）把可迭代对象转换为元组
Str（obj）把obj对象转换为字符串
Max（）返回序列或参数集合最大值
Sum（）叠加数据内容
Sorted（）将对象内容排序
Reversed（）返回一个迭代器对象，再用list可打印；list（reversed（a））
Enumerate（）返回一个对象，再用list可打印；
Zip（a，b）返回一个迭代器对象，再用list可打印；

&#8195;
第十七讲 函数
Def来定义
>>> def FirstFunction():
        print("My first function!")
创建完毕

调用函数
>>> FirstFunction()
My first function!

函数（）中可以添加参数，理论添加参数无限制
建议参数不要太多，每个参数写好备注，便于维护

函数返回值
使用return返回特定值
&#8195;
第十八讲
形参和实参
函数定义的是形式参数，传递进来的较实际参数；

函数文档
>>> def myfunction(name):
        "函数定义中的参数是形参"
        print("传递的" + name + "是实际参数")
>>> myfunction.__doc__
'函数定义中的参数是形参'
打印出来的是函数文档，为了更好的理解与调试

关键字参数
>>> def saysome(name, words):
        print(name + ":" + words)
为保证name和words不要顺序错误，可以通过关键词改变
>>> saysome(words="I love you",name="小山")
小山:I love you

默认参数
>>> def saysome(name="小山", words="I love you"):
        print(name + ":" + words)
放一个默认值，这样不怕忘了给实参

收集参数
>>> def test(*parass):      #加星号，表明是收集参数
        print("参数长度为：",len(parass))
        print("第二个数为：",parass[1])
>>> test(1,"hill",4,-98,15,"love","you")
参数长度为： 7
第二个数为： hill
注：若有收集参数和其他参数，其他参数需要用关键字参数

&#8195;
第十九讲
函数与过程
函数有返回值，过程无返回值
Python只有函数没有过程，没有return时会返回none的对象
Python可以返回多个值，可以使用列表或者元组

函数变量的作用域
即变量可见性
函数里面定义的参数称为局部变量，函数外是无效的；
全局变量是整个代码段，在函数外定义的

函数内部修改全局变量，会在函数内部新建同名的局部变量；函数最好不要改，只访问。

&#8195;
第二十讲
内嵌函数和闭包
Global  参数名   来确定修改全局变量

函数嵌套
>>> def fun1():
        print("fun1() is being called")
        def fun2():
                print("fun2 is being called")
        fun2()

>>> fun1()
fun1() is being called
fun2 is being called

注意：内部函数的整个作用域，都在外部函数之内；即fun1可随时调用fun2，出了fun1就不行了

闭包：函数式编程的重要语法结构
Python中闭包表现形式：如果在内部函数，对外部作用域变量引用，
>>> def funx(x):  #闭包
        def funy(y):
                return x*y
        return funy

>>> i = funx(52)
>>> i
<function funx.<locals>.funy at 0x0000000003281840>
>>> type(i)
<class 'function'>
>>> i(10)
520
>>> funx(52)(10)
520
注意， 一般内部函数不能修改外部函数变量
>>> def fun1():
        x = 5
        def fun2():
                x *= x
                return x
        return fun2()

>>> fun1()   #执行时会报错
修改办法，引进nonlocal方法
>>> def fun1():
        x = 5
        def fun2():
                nonlocal x
                x *= x
                return x
        return fun2()

>>> fun1()
25

&#8195;
第二十一讲  lambda
Python允许使用lambda关键字创建匿名函数；
匿名函数：
>>> def ds(x):   #可改写为下面的lambda
        return 2*x+1

>>> lambda x : 2 * x + 1   #：前为参数，：后为返回值
<function <lambda> at 0x0000000003281C80>
>>> g = lambda x : 2 * x + 1
>>> g(5)
11

Lambda表达式作用：
写执行代码时，lambda可以省下定义函数过程，精简代码；
抽象且整个程序只调用一两次函数，使用lambda可避免命名；
简化代码可读性，避免跳到函数def定义，再去阅读函数意义；

两个牛逼的BIF
Filter()   过滤器
>>> filter(None,[1,0,False,True])
<filter object at 0x0000000003154400>
>>> list(filter(None,[1,0,False,True]))
[1, True]   #将任何非True的元素过滤掉

>>> def odd(x):
        return x % 2

>>> temp = range(10)
>>> show = filter(odd,temp)   #按特定规则过滤
>>> list(show)
[1, 3, 5, 7, 9]
>>> list(filter(lambda x : x % 2,range(10)))
[1, 3, 5, 7, 9]

Map()  映射
两参数，函数和可迭代的序列；
功能：将序列每一个元素作为函数参数运算加工，直到加工完毕，生成新序列
>>> list(map(lambda x : x * 2,range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

&#8195;
第二十二讲 递归
设置递归层数，默认100层
>>> import sys
>>> sys.setrecursionlimit(10000)

阶乘递归实现
>>> def fun3(x):
        if x == 1:
                return 1
        else:
                return x * fun3(x-1)
1有正确的返回条件；2调用自己；



第二十三讲
斐波拉切数列实现方法
迭代
def fab1(n):
        n0 = 1
        n1 = 1
        n2 = 1
       
        while (n - 2) > 0:
                n2 = n0 + n1
                n0 = n1
                n1 = n2
                n -= 1
               
        return n2

a = fab1(20)
print(a)

递归
def fab2(n):

    if n == 1 or n ==2 :
        return 1
    else:
        return fab2(n-1) + fab2(n-2)

a = fab2(20)
print(a)
递归采用一种分治思想；

当数字改为35或更大时，递归等待时间会很长；会非常占用资源；