python:笔记

while　语句语法说明
　　１．先执行真值表达式，判断真假
　　２．如果为真则执行语句块１，然后跳转到第一步
　　３．如果为假，则执行else的语句块２，然后结束此while语句的执行，如果没有else则直接结束
　　４．else子句部分可省略


while注意事项：
　　１．要控制真值表达式来防止死循环
　　２．通常用真值表达式内的变量来控制循环条件
　　３．通常要在循环语句块内改变循环变量来控制循环的次数和变量的走向


练习：
　１．打印１－２０的整数，打印在一行内显示，每个数字之间用空格分开
　２．打印１－２０的整数，每行５个，打印４行
　３．用while语句打印１０－１的所有整数


练习：
１．while循环计算１＋２＋...+99+100
2.while打印直角三角型，输入一个整数表示三角形高度．




while语句嵌套
　　　while语句本身是语句，和其他语句一样，可以放在其他复合语句的内部
while嵌套示意
　while真值表达式：
　　    …
　　　while　真值表达式２：
　　　　   ...
　　　else:
                     …
            ...
      else:
             …


练习：
　　　输入一个数，打印指定宽度的正方形矩阵






break语句
　　　作用：用于循环语句（while,for 语句）中，用来种植当前循环语句的执行
break说明
　　当break语句执行后，此循环语句break之后的语句将不再执行
　　break语句通常和if语句组合式用
　　break语句终止循环时，循环语句的else子句的语句将不会执行
　　break语句只能终止当前循环语句的执行，如果由循环嵌套时，不会跳出嵌套的外层循环
　　break语句只能在循环语句（while或if语句）内部使用
死循环：
　死循环是指循环条件一直成立的循环
　死循环通常用break语句来终止循环
　死循环的else子句永远不会执行
while True:
       n=int(input(‘请输入:’))
       if n==0:
              break
       print(n)




练习：
１．任意输入一些整数，每次输入一个，当输入负数时结束，输入完成后打印您输入的这些数的和
２．写程序用while循环实现打印三角形，要求输入一个整数表示三角形的高度和宽度，打印三种直角三角形．
　１）
　　　＊
　　＊＊
　＊＊＊
＊＊＊＊
　２）
＊＊＊＊
　＊＊＊
　　＊＊
　　　＊
　３）
＊＊＊＊
＊＊＊
＊＊
＊
３．写程序求多项式的和
　１／１－１／３＋１／５－１／７＋１／９＋...＋１／(２＊n-1)=?  n最大取1000000
打印这个和
打印这个和乘以４的值，看看此数是否见过．










for语句
　　作用：用来遍历可迭代对象的数据元素


可迭代对象是指能以次获取数据元素的对象
　　可迭代对象包括：
　　　　字符串　str
　　　　列表list
          　　元组tuple
　　　　字典dict
　　　　集合set
　　　　...
for语句语法：
　for变量列表　in　可迭代对象：
　　　语句块１
　else:
    　　语句块２


for语法说明：
　　１．可迭代对象每次提供一个圆素依次赋值给变量列表中的变量．赋值完毕后执行语句块１，重复执行此步骤，直到可迭代对象不能提供数据为止
　　２．可迭代对象提供完所有元素后，执行else子句部分的语句块２，然后退出此for循环语句
　　３．else子句部分可省略（同while类似）
　　４．当在循环内部用break终止循环时，else子句部分不会执行




range函数
　　range(stop) 从零开始，每次生成一个整数后加１操作，直到stop为止（不包含stop）
　range（start,stop[,step]）从start开始，每次生成１个整数后移动step,直到stop为止（不包　　
　　含stop，且stop可能是负数）
说明：range返回的对象是可迭代对象，可以用于for语句中
　　range（4,0）　　#空




练习:
 1.用for语句打印1-20的整数，一行内
2.求100以内有哪些整数与自身加１的乘积再对１１求余＝８？
３．计算１＋３＋５＋...+99的和，用while和for两种语句实现




for语句的嵌套
　　for语句内部可以放任何语句，包括for　和while语句
练习：
１．写程序，输入一个整数n，代表正方形边长，打印数字组成的正方形
１２３４
１２３４
１２３４
１２３４


２．在题１的基础上，改变
１２３４
２３４５
３４５６
４５６７






continue语句
　　　作用：用于循环语句（while,for语句）中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
　　说明：
　　　１．在while语句中，执行continue语句将会直接跳转到while语句的真值表达式处重新判断循环条件
　　　２．在for语句中，执行continue语句，将会从可迭代对象中取下一个元素．绑定变量后再次进行循环
　　　for x in range(5):
                    if  x==2:
                        continue
                   print(x)


练习：
输入一个整数用begin绑定，再输入一个整数用end绑定，打印出从begin到end 包含end的所有偶数




＃用while循环打印１０以内的偶数


练习：
　求1-100］之间所有不能被５，７，１１整除的数的和？








循环总结：
　while语句(也有else用法)
　for语句(也有else用法)
　　　　－字符串
　　　　－range()　函数
break语句
continue语句






练习：
　　输入一个整数，判断这个整数是否是素数（素数只能被１和自身整除，１不是素数？？？？？？？？？？？？？？？？？？？？？？？？？）




列表list
　　列表是由一系列特定元素组成的，元素和元素之间没有任何关联，但有先后顺序
　　列表是一种容器
　　列表是序列的一种
　　列表是可以被改变的序列
python中的序列类型简介
　　　字符串　str
              列表　　list
              元组　　tuple
　　　字节串　bytes
　　　字节串组　bytearray


L=[]
L=[1,2,3,4]
L=[‘北京’,’上海’,’重庆’]
L=[1,2,[3.1,3.2,3.3],4]
L=[1,’two’,3,’四’]
列表的构造（创建）函数list
   list()生成一个空的列表　等同于［］
　list(iterable)用可迭代对象创建一个列表
示例：
　　　L=list()   ------>[]
            L=list(‘ABCDE’)-----＞[‘A’,’B’,’C’,’D’,’E’]
           L=list(range(1,10,2))----->［1,3,5,7,9］


列表的运算
　　算术运算
　　　　+ +=  * *=
+用于拼接列表
+=用于原列表与右侧可迭代对象进行拼接，生成新列表
Ｌ+='456'
[1, 2, 3, '4', '5', '6']


＊生成重复列表
＊＝用于生成重复列表，同时用变量绑定新列表




列表的比较运算
　　运算符
　　< <=  >  >=  ==   !=




练习：
１．输入一个整数，代表树干的高度，打印一颗圣诞树
２．用循环语句生成如下字符串
　　　＇ＡＢＣ．．．．ＸＹＺ＇
　　　＇ＡaBbCc……     XxYyZz＇
　用ord和chr函数结合循环语句实现


３．算出１００－９９９以内的水仙花数，是指百位的三次方加上十位的三次方加上个位的三次方＝数字本身（如153＝1**3+5**3+3**3)






列表的in/not in
　判断一个元素是否在容器内，如果存在返回True，否则返回False
　not in　的返回值与in运算符相反
　示例
　　x=[1,’Two’,3,14,’四’]
　　　１in　x　　　#True
　　　2 in x                #False
              3 not in x         #True
            ‘四’not in x   #False 


列表的索引index  ／切片　slice
     列表的索引语法：
　　　列表［整数表达式］
　　用法：
　　　　列表的索引取值与字符串的索引取值规则完全相同
　　　　列表的索引分为正向索引和反向索引
　　　示例
　　　　L=[‘A’,2,’B’,3]
                  print(L[1])      #2


索引的赋值操作
　　列表是可变的序列，可以通过索引赋值改变列表中的元素
语法
　列表［索引］＝表达式
x=[1,2,3,4]
x[2]=3.14
                         #x=[1,2,3.14,4]




列表的切片
　　列表[:]
    列表的[::]
  列表的切片取值返回一个列表，规则等同于字符串的切片规则
　x=list(range(9))
   y=x[1:9 :2]    #y=[1,3,5,7]






列表的切片赋值操作
　列表[切片］＝可迭代对象
说明：
　切片赋值的赋值运算符的右侧必须是一个可迭代对象
　L=[2,3,4]
 L[0:1]=[1.1,1.2]
print(L)     #[1.1,1.2,3,4]
L=[2,3,4]
L[:]=[7,8]




切片步长不为１的切片赋值
　　　l=list(range(1,9))
      l[1::2]=[2.2,4.4,6.6,8.8]
  print(l)




注意事项：
　　对于步长不等于１十位的切片赋值，赋值运算符的右侧的可迭代对象提供元素的个数来一定要等于切片切出的段数




del语句用于删除列表元素
　语法：
　　del列表［索引］
　　del列表［切片］


L=[1,2,3,4,5,6]
del L[0]   #L=[2,3,4,5,6]
del L[-1]   #L=[2,3,4,5]
L=[1,2,3,4,5,6]
del L[::2]   #L=[2,4,6]




python3中常用的序列函数
　　len(x)返回序列的长度
　　　max(x)   返回序列的最大值元素
　　　　min(x)  返回序列的最小值元素
　　　　sum(x)　返回序列中所有元素的和（元素必须是数值类型
　　　　any(x)  真值测试，如果列表中其中一个值为真值则返回True，否则返回False
　　　　　all(x)真值测试，如果列表中所有值为真值则返回True，只要有一个为假，则返回False




练习：
　　一直有列表L=[3,5]用索引和切片操作，将列表变为L=[1,2,3,4,5,6]
将列表反转，然后删除最后一个元素，print
   2.写程序让用户循环输入一些整数，当输入－１时结束输入，将这些数存于表中
　 1.打印您供输入几次有效的数
　　２．打印输入的最大和最小数
　　　　３．打印这些数的平均值
　　
　　写一个程序，输入多行文字，当输入空行式结束，将字符串存于列表中




字符串文本解析split和join
　　S.split(sep=None) 将字符串使用sep作为分隔符分隔S字符串，返回分隔后的字符串的列表，当不给定参数时，用空白字符作为分隔符来进行分隔
s=’Beijing is capital’
L=s.split(‘’)    #L=[‘Beijing’,’is’,’capital’
s=’\\’
L=[‘C:’,’Programing files’,’python3’]
s2=s.join(L)    #s2=’C:\Programing files\Python3’




深拷贝deep　copy   浅拷贝　　shallow copy






浅拷贝:复制时只复制一层变量，不会复制深层变量绑定的对象的赋值过程
L=[3.1 ,3.2]
L1=[1,2,L]
L2=L1.copy()
print(L1)  #[1,2,[3.1,3.2]]
print(L2)  #[1,2,[3.1,3.2]]
L2[2][0]=3.14
print(L1)  #[1,2,[3.14,3.2]]
print(L2)  #[1,2,[3.14,3.2]]






深拷贝　（通常只对可变对象进行复制，不可变对象通常不变
（字符串的+=就是创建新的字符串，字符串不可变）
import　copy　＃导入copy模块
Ｌ=[3.1 ,3.2]
L1=[1,2,L]
L2=copy.deepcopy(L1)
print(L1)  #[1,2,[3.1,3.2]]
print(L2)  #[1,2,[3.1,3.2]]
L2[2][0]=3.14
print(L1)  #[1,2,[3.1,3.2]]
print(L2)  #[1,2,[3.14,3.2]]




列表推导式list comprehension
　列表推导式是　用可迭代对象依次生成带有多个元素的列表的表达式
　作用：用简洁方法生成列表
　语法：［表达式　for　变量　in 可迭代对象］
　　　或
　　　　［表达式　for　变量　in 可迭代对象　if　真值表达式］
示例：
　　　＃以下生成一个数值为１－９的平方的列表
　　L=[x*x for x in range(1,10)]




练习：
　　用列表推导式生成１－１００内的奇数的列表




列表推导式的嵌套
　　语法：
　　［表达式１　for　变量１　in　可迭代对象１　if　真值表达式１　for　变量２　in　可迭代对象２　if　真值表达式２．．．］
　L1=[2,3,5]
   L2=[7,11,13]
    #将L1中的全部元素与L2中的全部元素依次相乘后放到L3中
L3=[x*y for x in L1 for y in L2]






练习：
　　1.用字符串s=’ABC’和s2=’123’生成如下列表：
　　［A1,’A2’,’A3’,’B1’,’B2’,’B3’,’C1’,’C2’,’C3’]
        2. 有一些数存在列表L中，L=[1,3,2,1,6,4,2,…,98,82]自定义
　　　将L中的是存于L2中，要求重复出现多次的数字只在L2列表中保留一份


３．生成前４０个斐波那契数１１２３５８．．．
　　自第三个起，之后的所有数为前两个数之和，要求这些数保存在列表中，最后打印列表
　　用循环和列表或变量组合可以实现




列表可以存储任意类型的数据，但可变，不安全


元组　tuple 可迭代
   　存储任何的数据对象，不可变序列
　元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，一旦元组生成，不可变．


元组的表示方式
　用小括号（）扩起来，单个元素扩起来用逗号区分是单个对象还是元组
创建空元组的字符值
　   t=()
创建非空元组的字面值
t=200,
t=(20,)
t=(1,2,3)
t=100,200,300


元组的构成函数tuple
　　tuple()生成一个空的元组，等同于（）
　　tuple（iterable）用可迭代对象生成一个元组
示例：
　　t=tuple()
      t=tuple(range(10))
t=tuple(‘abc’)
t=tuple([1,2,3,4])
t=tuple(（5,6,7,8）)


元组的算术运算：
　+ +=  *  *=
            用法与列表相同
元组的运算比较：
　< <=  > >= == !+




in／not in
索引切片
切片取值
　　规则与列表完全相同
区别：
元组是不可变对象，不支持索引赋值和切片赋值
［人的脑袋不能闲着，一闲着就容易犯傻逼］


可以用于序列的函数
　　len,max,min ,sum,all,any


三个构造函数
　str(obj)
list(iterasble)
tuple(iterable)




其他函数
　reversed(seq) （反转过的）  返回反向顺序的可迭代对象
　sorted(iterable,reversed=False)返回已排序的列表


示例
　　for x in reversed(‘ABCD’)
              print(x)    # D C B A
   L=[8,6,3,5,7]
L2=sorted(L)   #[3,5,6,7,8]
L3=sorted(L,reverse=True)
     # L3=[8,7,6,5,3]
L不变






字典dict
1.字典是一种可变的容器，可存储任意类型的数据
２．字典中的每个数据都是要键key进行索引，而不像序列可以用下标来进行搜索
３．字典的数据没有先后顺序，字典的存储是无序的
４．字典的数据以键key-值value对　进行映射存储
５．字典的键不能重复，且只能用不可变类型作为字典的键．


字典的字面值表示方式：
　　用｛｝括起来，以冒号：分隔键－值对，各键值对用分号分开


创建空字典
d={}


创建非空字典
d={‘name’:’tarena’,’age’:15}
d={‘姓名’：＇小张＇}
d={1:＇壹＇，2：＇贰＇}                                                                                                                   




字典的构造函数dict     
dict()创建空字典　　等同于｛｝
dict(iterable)用可迭代对象初始化一个字典
dict(**kwargs) 关键字传参形式生成字典


示例：
　　d=dict()
   d=dict([(‘name’,’tarena’),(‘age’,15)])
 d=dict(name=’tarena’,age=15)


不可变类型：
　int float complex,bool,str,tuple.frozenset(固定集合),bytes(字节串)


可变类型：
　　list dict set bytearray(字节数组)




字典的键索引
　　用［］运算符可以获取字典以内键　所对应的值　
　　　　语法：
　　　　　字典［键］
　　获取数据元素
　d=dict(name=‘tarena’,age=15)
   print(d[‘age’])    #15


添加和修改字典的元素
　　字典［键］＝表达式


示例：d={}
    d[‘name’] = ‘tarena’　　　创建一个新的键值对
  d[‘age’]=15                 创建键值对                                                                                                                  
d[‘age’]=18                修改键值对    


del　语句删除字典的元素
语法：
　　del 字典［键］
示例：
　　　d={‘name’:’china’,’pos’:’asia’}
    del d[‘pos’]
     print (d)    #d={‘name’:’china’} 
   del d[‘name’]
  print(d)    #{}                                                                                                                                        




字典的in／not in 运算符
可以用in　运算符来判断一个键是否存在于字典中，如果存在返回True，否则返回False
 Not in 与in返回值相反


示例:
     d={‘a’:1,’b’:2}
  ‘a’ in d   #True
    1 in d  #False
   100 not in d #True
  2 not in d　　#True




字典的迭代访问
　　字典是可迭代的对象，字典只能对键进行迭代访问
　d={‘name’:’tarena’,(2002,1,1):’生日’}
　for x in d:
          print(x)


可以用于字典的内建函数
　　len(x)    返回字典键值对的个数
　　max(x)  返回字典的键的最大值
　　min(x)  返回字典的键的最小值   
　　sum(x) 返回字典的所有键的和
　　any(x)  真值测试，只对键测试，如果其中一个键为True,结果True
         all(x)  真值测试，全部为True,结果才为True




练习：
　　　写程序，实现以下需求：
　　　　　　将如下数据形成一个字典seasons
       键　　　　　　　　值
　　１　　　　　　春季由１２３月
　　２　　　　　　夏季．．．
　　３　　　　　　秋季有．．．
　　４　　　　　　冬季．．．
　　让用户输入一个整数代表这个季度，打印季度信息，如果摄入的信息不在字典的键内，则打印信息不存在
                   


２．写程序，输入一段字符，打印出这个字符串中出现过的字符及出现过得次数                      




字典推导式
　　是用可迭代对象依次生成字典内元素的表达式
语法：
｛键表达式：值表达式　for　变量　in　可迭代对象　if真值表达式｝
d={x:x**2 for x in range(10)}                                                                                                                


练习：
　1.　   字符串列表如下
　　L=[‘tarena’,’xiaozhang’,’xiaowang’]        
  生成字典如下
　　d={‘tarena’:6,’xiaozhang’:9,’xiaowang’:8}         


2.    编号列表如下
　Nos=[1001,1002,1003,1004]
 names=[‘Tom’,’Jerry’,’Spike’,’Tyke’]   
生成用Nos为键，以names为值的字典
｛1001:’Tom’,….｝                                                                                                                                              




练习：
１．写程序，输入一些单词和解释，将单词作为键，解释作为值，保存在字典中
　　　然后：输入查询的单词，显示出此单词的内容    
２．学生管理项目准备工作：
　　　写程序，任意输入N个学生信息．存为字典后存于列表中
　　　学生信息包括：
　　　姓名　字符串
　　　年龄　整型
　　　成绩　整型
循环输入学生信息，直到输入学生姓名为空结束输入
最后形成字典如下：
　　L=[
                     {‘name’:’xiaozhang’,’age’:20,’score’:100}
                      {‘name’:’xiaoli’,’age’:21,’score’:98}
                     {‘name’:’xiaowang’,’age’:19,’score’:89}
                    …
                ]      
将以上列表显示为如下的表格
+------------------------+------------------------+-----------------------+
 |        name                 |        age                   |       score                  |
+------------------------+------------------------+------------------------+
|    xiaozhang              |           20                  |      100                     |
|       xiaoli                  |            21                 |       98                      |                                                                                                                                                
|     xiaowang              |           19                 |            89                  |                                                        
+-------------------------+-----------------------+------------------------+