python的语法小结

break 与continue的区别：

　　1、break是直接中断全部循环

　　2、continue则是在只不执行此次所循环的东西，其它循环依旧执行，比方说只是跳过第4次循环，第5次循环照常进行。

\n 表示换行符，end=""表示不换行；

\r 回车 （把光标移动到当前行的第一个位置）

\r\n 换行回车

因为在print里面有一个默认的end，所以print（）就表示换行。默认的是print（end=“\n”）

对于for循环的一些认识：

　　for i in range(3):                       range(1,3)   >>>>>>>1,2

　　　　print(i)                              range(1,11,2)  >>>>>>>1,3,5,7,9          此处表示的步长为2

>>>>>0,1,2

基础知识小结

　　9/2=4.5            9//2=4（整除）           9%2=1（取余）            2^**10=1024

要想内层循环和外层循环相关联，则最好用上标志位flag。后面会有总结。

列表 []

比如：a=["wuchao","jinxing","xiaohu","sanpang","ligang"]

要掌握的内容#增删改查

print(a[3])                 >>>>>>sanpang

1、增      切片

print(a[1:3])          <记住：这个列表此操作也叫切片，左包括，右不包括>                      >>>>>>['jinxing', 'xiaohu']

print(a[1:])               取到底                             >>>>>>['jinxing', 'xiaohu', 'sanpang', 'ligang']

print(a[1:-1])           -1表示取到倒数第二个元素                 >>>>>>['jinxing', 'xiaohu', 'sanpang']

print(a[1:-1:1])           最右边的1表示步长，表示从左到右一个一个取       >>>>>>['jinxing', 'xiaohu', 'sanpang']

print(a[3::-1])              -1表示从右往左取                             >>>>>>['sanpang', 'xiaohu', 'jinxing', 'wuchao']

#append 表示直接放在列表的最后一个位置上                 #insert  表示可以放在任何的位置

例如：a.append("xuepeng")            >>>>>>['wuchao', 'jinxing', 'xiaohu', 'sanpang', 'ligang', 'xuepeng']

a.insert(1,"xuepeng")            >>>>>>['wuchao', 'xuepeng', 'jinxing', 'xiaohu', 'sanpang', 'ligang']

#修改

a[1]="haidilao"          改第二个元素       >>>>>> ['wuchao', 'haidilao', 'xiaohu', 'sanpang', 'ligang']

a[1:3]=["a","b"]          改第二，三个元素         >>>>>>['wuchao', 'a', 'b', 'sanpang', 'ligang']

#删除    remove      pop     del

a.remove("wuchao")          #删谁就把谁的名字放进去

a.pop(1)                              #删除对应索引值得元素，并且b=a.pop(1)   print b     可以打印删除的值       >>>>>>jinxing

a.pop()                                #删除并返回最后一个值  b=a.pop()   print（a） print(a.pop())                                       >>>>>>['wuchao', 'jinxing', 'xiaohu', 'sanpang']           sanpang

值得注意的是： 为什么返回值是sanpang而不是ligang,因为前面有一个b=a.pop()的代码，已经把ligang作为返回值删掉了，等到运行到print（a.pop()）时，最后一项时sanpang

del    #什么都能删del a[0]  删第一个  del a   a列表全删     del a[0] print(a)  >>>>>>>['jinxing', 'xiaohu', 'sanpang', 'ligang']  a.clear()   清空   只剩一个中括号   print a    只是一个中括号>>>>>>>[] 

count：计算某元素出现的次数         t=["to","be","or","not","to","be"].count("to")      print(t)  >>>>>>2

extend    #添加       a=[1,2,3]    b=[4,5,6]      a.extend(b)        print(a)        >>>>>>[1, 2, 3, 4, 5, 6]

如果是a=[1,2,3]   a.extend("mengheng")     print(a)    >>>>>>[1, 2, 3, 'm', 'e', 'n', 'g', 'h', 'e', 'n', 'g']

index                       print(a.index("jinxing"))                           >>>>>>1

reverse    #将列表元素倒过来      a.reverse()           print(a)         >>>>>>['ligang', 'sanpang', 'xiaohu', 'jinxing', 'wuchao']

sort           #排序        x=[4,6,2,1,7,9]                      x.sort()           print(x)   >>>>>>[1, 2, 4, 6, 7, 9]

身份认证           type             #type(a) is list                              >>>>>>true

列表的嵌套：

a=[[1,2,3],"alex",4,(2,3,4)]       print(a[0][1])   #表示取了第一个列表里面的第2个元素 >>>>>>2

#实践环节 如何把一个列表中的程序一行一行的输出，这就要用到循环的遍历，因为print自带的就是换行

　　　　　　product_list=[("mac",9000),("kindle",800),("tesla",900000),("python book",105)]

　　　　　   for i in product_list:

　　　　　　　　print(i)

　　　　>>>>>>

('mac', 9000)
                                                                   ('kindle', 800)
                                                                   ('tesla', 900000)
                                                                   ('python book', 105)

　　　　　　enumerate()       #可以在之前加一些编号

                                                                               for i,v in enumerate(product_list,1):  #1表示的是索引的初始值
                                                                                         print(i,">>>>>",v)
                                                                         >>>>>>

　　　　　　　　　　　　　　　　　　　　　　　　　　　　1 >>>>> ('mac', 9000)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　2 >>>>> ('kindle', 800)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　3 >>>>> ('tesla', 900000)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　4 >>>>> ('python book', 105)

a,b=[2,3]          print(a)    print(b)          >>>>>>2,3             #会给你分配对应的值

计算list的长度      len(product_list)   >>>>>>4

不可变类型 ：整型 ，字符串 ，元组                                                    可变类型：列表，字典

字典

　　字典是由一群键值对组成。dic={1:"mengheng","age":35,"hobby":{"girl_name":"铁锤","age":45},"is_handsome":true}  #键一定是不可变的。所以列表和字典都不能成为字典的键，而值是可变的。              print(dic["hobby"])        >>>>>>{'girl_name': '铁锤', 'age': 45}

　　查找列表中的元素是依据索引，而字典则是依据字典中的键来找对应的值

　　字典的两个特点：无序，键唯一

创建列表的两种方法：1、a=[1,2,3]                    2、a=list((1,2,3))            print (a)  >>>>>>[1,2,3]

创建字典的两种方法：1、dic1={}                       2、dic2=dict((("name","mengheng"),))    >>>>>>{'name': 'mengheng'}

增加键值对：    dic1={}      dic1={"name":"mengheng"}    dic1["age"]=18    print(dic1)  >>>>>>{'name': 'mengheng', 'age': 18}

另一种方法：dic1.setdefault("hobby","girl")                  如果原字典中有了"hobby" 则不加，还用原来的，并且将字典里的值作为返回值，返回到hobby中

如果没有就添加

查    通过键查找：

　　dic3={"age":18,"name":"mengheng","hobby":"girl"}

　　print(dic3["name"])　　　　　　>>>>>>mengheng

　　print(dic3.keys())              #输出所有的键              >>>>>>

　　print(dic3[list(dic3.keys())[0]])     #换汤不换药，其实list(dic3.keys())[0]就是所有键值对列表中的第一个元素

改

　　1、dic3["age"]=55

　　2、dic4={"age":18,"name":"mengheng","hobby":"girl"}             dic5={"1":"111","2":"222"}

　　　　dic4.update(dic5)         print(dic4)      print(dic5)             >>>>>>{'age': 18, 'name': 'mengheng', 'hobby': 'girl', '1': '111', '2': '222'}       {'1': '111', '2': '222'}

　　　　dic5 不变    dic4中添加了dic5

删

　　dic5.clear()                  #清空字典            print(dic5)  >>>>>>{}

　　del dic4["name"]             #删除字典中指定键值对 >>>>>>{'age': 18, 'hobby': 'girl'}

　　dic4.pop("age")              #删除字典中指定的键值对，并返回键值对的值     print(dic4.pop("age") )  >>>>>>18

　　a=dic5.popitem()            #随机删除其键值对，并返回值

　　del dic5                          #删除整个字典

字典的遍历：

　　dic5={"age":18,"name":"mengheng","hobby":"girl"}

　　1、for i in dic5:

print(i,dic5[i])               #这个方法最好用

>>>>>>age 18

name mengheng

                hobby girl

　　2、for i in dic5.items():                    #items   属于键值对

　　　　　　print i

>>>>>>('age', 18)

                ('name', 'mengheng')
                ('hobby', 'girl')

　　3、for i, v in dic5.items():

　　　　　　print(i,v)

>>>>>>age 18

                name mengheng
                hobby girl

字符串：

　　格式化输出：

　　　　print("%s is a good teacher"%"alex")         >>>>>>alex is a good teacher

　　将两个字符串拼接起来，可以用“+”，但是效率比较高的是join

　　a="123"     b="abc"     c="".join([a,b])     print(c)       >>>>>>123abc

　　字符串的内置方法：

　　先罗列比较重要的：st="hello kitty"

　　print(st.count("l"))                   #统计元素个数

　　print(st.center(50,"-"))                   #50个字符，除了hello Kitty 其余都用“-”表示   >>>>>>-------------------hello ketty--------------------

　　print(st.startswith("he"))                   #判断以某个内容开头                                   >>>>>>true

　　print(st.find("t"))                   #查找到第一个元素并将索引值返回                          >>>>>>8

　　print(st.format(name="alex"))                   #其中st="hello kitty{name}"                  >>>>>>hello kittyalex       格式化输出的另一种方式

　　print(st.islower())                   #判断是否全为小写字母                                           >>>>>>true

　　print(st.isupper())                   #判断是否全为大写字母                                          >>>>>>false

　　print("my title".strip())                   #去掉换行符和空格

　　print("my title".lstrip())                   #去掉左边的换行符和空格

　　print("my title".rstrip())                   #去掉右边的换行符和空格

　　print("my title".replace("itle","lesson"))                   #替换                                       >>>>>>my tlesson

　　print("my title title".split(" "))                   #将字符串分割成列表                              >>>>>>['my', 'title', 'title']

　　print("my title title".split("-"))                   #变成一个整的元素                                  >>>>>>['my title title']

　　如果想把列表转换成字符串则用join       print("".join(['my', 'title', 'title']))                 >>>>>>mytitletitle

三级菜单的小程序

menu={"江苏省":{"南京市":["玄武区","江宁区","六合区","鼓楼区"],
            "泰州市": ["海陵区", "姜堰区", "泰兴区", "兴化区"],
            "连云港市": ["新浦区", "灌南县", "灌云县", "东海县"]},
     "浙江省":{"杭州":["桐庐","淳安","萧山","建德"],
            "宁波": ["象山", "宁海", "余姚", "慈溪"],
            "温州": ["洞头", "永嘉", "平阳", "苍南"],},
     "山东省":{"济南":["长青","平阴","济阳","商河"],
            "青岛": ["胶州", "平度", "胶南", "四方"],
            "烟台": ["福山", "莱山", "长岛", "龙口"]}}

exit_flag=False
while not exit_flag:
    for key in menu:
        print(key)
    choice=input("1>>:").strip()
    if choice=="q":
        exit_flag=True
    elif choice in menu:
        while not exit_flag:
            for key2 in menu[choice]:
                print(key2)
            choice2 = input("2>>:").strip()
            if choice2 == "b":
                break
            elif choice2 == "q":
                exit_flag = True
            elif choice2 in menu[choice]:
                while not exit_flag:
                    for key3 in menu[choice][choice2]:
                        print(key3)
                    choice3 = input("3>>:").strip()
                    if choice3 == "b":
                        break
                    if choice3 == "q":
                        exit_flag = True

高端版三级菜单：

current_layer_read=open("menu_file","r+",encoding="utf8")
with current_layer_read as current_layer_read:
    current_layer_read=eval(current_layer_read.read().strip())

# current_layer_append=open("menu_file","a",encoding="utf8")
parent_layers=[]
flag=False
while not flag:
    for key in current_layer_read:
        print(key)
    choice=input(">>>:").strip()
    if len(choice)==0:
        continue
    if choice in current_layer_read:
        if type(current_layer_read)==list:
            print("到底了")
            break
        else:
                parent_layers.append(current_layer_read)
                current_layer_read = current_layer_read[choice]

    elif choice =="b":
        if parent_layers:
            current_layer_read=parent_layers.pop()#pop()是删除最后一项并将所删除的最后一项作为返回值
    else:
        print("无此项")

能调用方法的一定是对象

　　如：li=[1,2,3]           li.append("2")   #其中li就是对象，而append就是方法

　　文件本身也是对象

文件的读写操作：

　　其中“小重山”的文件内容是

昨夜寒蛩不住鸣。
惊回千里梦，已三更。
起来独自绕阶行。
人悄悄，帘外月胧明。
白首为功名，旧山松竹老，阻归程。
欲将心事付瑶琴。
知音少，弦断有谁听。
　　f=open("小重山","r",encoding="utf8")                               a 写模式，append是在后面添加
　　data=f.read()                        #data=f.read(5)   >>>>>>昨夜寒 *不           w 写模式，之前的文件内容会被清空，所以并不常用

        print(data)

　　f.close()　
readline的用法：print(f.readline())          #默认是第一行，括号里面是几就会打印几个字符，没有数字就打印一整行。
readlines的用法：print(f.readlines())       #不写几行就是打印所有行，且以列表的方式呈现，而且可以打印换行符
因为读出来的是列表，所以要用for循环读取文件
　　for i in f.readlines():
　　　　print(i.strip())               #因为print是自带换行，所以要去掉readlines打印出来的换行符，
　　　　　　　　　　　　　　不然连着print的自动换行一起，就会出现两行文字之间还会隔一行的现象
用readlines读取文件有一些局限性，比方说它都是一次性把文件全部读到内存的，这样就会在当文件很大的时候读取之后会占很多内存，不方便
而下面的方法完美的解决了这个问题：
　　for i in f:                                      #这是for内部将f对象做成一个迭代器，用一行取一行，这样就不会占内存了
　　　　print(i.strip())

　　print(f.tell())                        >>>>>>打印光标的位置

f=open("小重山","r",encoding="utf8")   
print(f.tell())                                                            >>>>>>0                               #刚开始默认是0
print(f.read(2))                                                         >>>>>>昨夜                 
print(f.tell())                                                             >>>>>>6                              #一个汉字相当于3个字节
调节光标的位置：
f.seek(0)
f.flush()                              #将缓存的数据存到磁盘上，为的是在突然断电的时候不会有数据丢失
#r+,w+,a+   可读可写

print(f.readline())
f.write("岳飞")                      #该怎么读就怎么读，写东西是在整个文档的最后面写
f.close()

w+ 还是先清空，再写

f=open("小重山","w+",encoding="utf8") 

print(f.readline())                              >>>>>>                 #读出来的是空白，因为清空过了
f.write("岳飞")                                  >>>>>>岳飞         #文本里被写入“岳飞”光标的后面
print(f.tell())                                      >>>>>>6                #查找光标位置并输出，一个汉字相当于3个光标，所以输出的是6.
f.seek(0)                                            >>>>>>                   #将光标输到0的位置，就是刚开始的位置。
print(f.readline())                              >>>>>>岳飞          #如果没有f.seek(0)则它读的只是光标以后的一行，是空白。所以要想读出数据，必须要加f.seek(0)
f.close()

a+

f=open("小重山","w+",encoding="utf8") 
print(f.tell())                                   >>>>>>224             #添加文件是在文件最后添加，所以光标是在最后
print(f.readline())                            >>>>>>                   #当光标在最后就读不出东西了
f.close()

终极问题

修改文件
因为write写文件只能是在文件的末尾端写，文件的中间如果想改，单单靠源文件是不够的，所以就想到了一个方法，就是有write创建一个
新的文件，然后用i循环一个个的遍历，到哪一行就添加相应的东西，虽然比较繁琐但是是目前最有效的方法了。

f_read=open("小重山","r",encoding="utf8")
f_write=open("小重山2","w",encoding="utf8")#用write方法创建一个新的文件
num=0
for line in f_read:#用for循环实现遍历
    num+=1
    if num==5:
        line="".join([line.strip(),"mengheng\n"])#在第5行的时候添加文字，要注意换行符的使用
        f_write.write(line)#write方法只能在文本的末端使用
    else:
        f_write.write(line)
f_write.close()
f_read.close()

 将字典变成字符串的方法             a=str({"beijing":{"1":111}})  因为文件里面的都是字符串类型
要想将字符串类型重新转成字典型，a=eval(a)。

with 的用法：为了避免使用close。
f=open("log","r")            f.readline()      f.read()      f.close()
with open("log","r") as f:         f.readline()     f.read()                      这两种是等价的，当明显第二种更方便一点
下面展示从文件中读取的三级菜单：

with open('menu_file','r',encoding='utf8') as f_read:
    geography_menu = eval(f_read.read().strip())#因为文本中只能是字符串类型，所以要转换成原来字典类型，用eval

#定义一个动态字典来进行多级选择，并初始化为geography_menu
dynamic_dict = geography_menu
#定义一个用户列表来接收dynamic_dict的父字典的键，以便用户选择返回上级
dynamic_dict_super = []#是为了在输入b的时候返回上一级
#增删改查还没有保存在文件中
while True:
    print('欢迎使用'.center(50,'*'))
    for i in dynamic_dict:
        print('>>>',i)
    user_choice = input('请输入选择：输入你要查询的地区省市或新增[add]、修改[revise]、删除[delete]、返回上一级[q]').strip()
    #print(dynamic_dict)#测试当前屋为什么类型
    #查询
    if user_choice in dynamic_dict:
        dynamic_dict_super.append(dynamic_dict)
        if type(dynamic_dict) == list:#如果是列表表明已经到了最后一级
            print('你选择的城市为：',user_choice)
            break
        else:
            dynamic_dict = dynamic_dict[user_choice]#相当于取字典的值，因为值就相当于是下一级
    #新增
    elif user_choice == 'add':
        user_add = input('请输入你要添加的省市区:').strip()
        if user_add in dynamic_dict:
            print('此项已存在，请重新输入：')
        else:
            if type(dynamic_dict) == list:
                dynamic_dict.append(user_add)#当类型为list时，需要判断
            else:
                dynamic_dict[user_add] = {}#这就是添加字典的方法，use_add是键，而{}是值
            continue
    #修改
    elif user_choice == 'revise':
        user_revise = input('请输入你要修改的省市区:').strip()
        if user_revise in dynamic_dict:
            user_revise_after = input('修改为：').strip()
            print(type(dynamic_dict))
            if type(dynamic_dict) == list:#当类型为list时，需要判断
                dynamic_dict[dynamic_dict.index(user_revise)] = user_revise_after
            else:
                dynamic_dict[user_revise_after] = dynamic_dict[user_revise]#将user_revise的值赋给user_revise_after
                del dynamic_dict[user_revise]
            continue
        else:
            print('此项不存在，请重新输入：')
    #删除
    elif user_choice == 'delete':
        user_delete = input('请输入你要删除的省市区:').strip()
        if user_delete in dynamic_dict:
            dynamic_dict_super.append(dynamic_dict)
            if type(dynamic_dict) == list:#当类型为list时，需要判断
                del dynamic_dict[dynamic_dict.index(user_delete)]
            else:
                del dynamic_dict[user_delete]
            continue
        else:
            print('此项不存在，请重新输入：')
    #返回上一级或退出
    elif user_choice == 'q':
        if dynamic_dict_super:
            dynamic_dict = dynamic_dict_super.pop()
        else:
            print('目前为最上级菜单，输入q后为退出系统！')
            break
    else:
        print("输入非法，请重新输入选择！")

 数据结构之深浅拷贝
　　s=[1,"alex","alvin"]
　　s2=s.copy()
　　print(s2)                              >>>>>>[1, 'alex', 'alvin']                         s和s2一样
　　之后对s2进行操作，s都不会受影响。但是对列表的操作，都会跟着变
　　

s=[1,"alex","alvin"]
s2=s.copy()
s[2]="mengheng"
print(s2)
print(s)      
>>>>>>

[1, 'alex', 'mengheng']
[1, 'alex', 'alvin']

但是当s里面会有列表的时候，情况就不一样了，也会跟着变

s=[[1,2,3],"alex","alvin"]
s2=s.copy()
s[0][1]="mengheng"
print(s)
print(s2)
>>>>>>

[[1, 'mengheng', 3], 'alex', 'alvin']
[[1, 'mengheng', 3], 'alex', 'alvin']                     #s和s2都改变了

　　浅拷贝=只拷贝第一层                     深拷贝是直接克隆一份           实际情况浅拷贝应用更多

　　集合  重点

　　集合是把不同的元素组合到一起，相同的元素会删掉多余的

　　s=set("meng heng")

　　print(s)                              >>>>>>{'n', 'e', ' ', 'h', 'g', 'm'}           无序的，而且会删掉重复多余的元素

　　应用之一：简单的去重

　　s1=["alvin","ee","alvin"]

　　print(set(s1))                    >>>>>>{"alvin","ee"}      #这里所要强调的一点是：1、set的元素是不可变的，

　　　　　　　　　　　　　　　　　　　　　　　　所以set的集合里面的元素

不能是列表和字典。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2、set过的元素不能再作为键

　　比如：li=[2,3,"meng"]

　　　　　s=set(li)

　　　　　print(s)

　　　　　d={s:"123"}                 >>>>>>报错，因为s已经set过了，不能再作为字典的键了；

　　下面有几种不同的添加方式：add()      update()

　　li=[2,3,"meng"]

　　s=set(li)

　　s.add("heng")            #添加的是整体

　　print(s)                   >>>>>>{2, 3, 'heng', 'meng'}

　　li=[2,3,"meng"]

　　s=set(li)

　　s.update("heng")        #输入一个字符串，它会把它拆散了添加

　　print(s)                   >>>>>>{2, 3, 'e', 'h', 'meng', 'n', 'g'}

　　li=[2,3,"meng"]

　　s=set(li)

　　s.update(["heng","25"])          #当输入一个列表的时候，直接添加

　　print(s)                >>>>>>{2, 3, 'heng', '25', 'meng'}

　　删除     #remove

　　li=[2,3,"meng"]

　　s.remove(2)

　　print(s)                                  >>>>>["meng",3]

集合还有的概念就是：交集、并集、差集

　　a=set([1,2,3,4,5])               b=set([4,5,6,7,8])

　　#intersection() 交集

　　print(a.intersection(b))    /print(a&b)                  >>>>>>{4,5}

　　#union() 并集

　　print(a.union(b))     / print(a|b)                          >>>>>>{1, 2, 3, 4, 5, 6, 7, 8}

　　#差集

　　print(a.difference(b))  /print(a-b)      #in a but not in b            >>>>>>{1,2,3}

　　#对称差集

　　print(a.symmetric_difference(b))  / print(a^b)                           >>>>>>{1, 2, 3, 6, 7, 8}

　　#判断是否为子集

　　print(a.issuperset(b))                 #a>b                            >>>>>>false