字符串操作

name='my \tname is {name} and i am {year} old'

print(name.capitalize())#首字母大写，

print(name.count('a'))#统计a的数量

print(name.center(50,'-'))#打印50个字符不够使用-

print(name.encode)#转换二进制

print(name.endswith('chao'))#以什么结尾，

print(name.expandtabs(tabsize=30))#转换多少个空格，字符串上必须加  ‘\t’

print(name[name.find('name'):9])#切片9之前的所有字符

print(name.format(name='zhangchao',year=29))#格式化，与下语句输出一致，原字符串必须增加name,year

print(name.format_map({'name':'zhangchao','year':''}))#格式化，与上语句输出一致

print('ab123'.isalnum())#包含字母数字，

print('aB'.isalpha())#包含大小写英文，

print(''.isdecimal())#10进制

print(''.isdigit())#是否整数，

print('A'.isidentifier())#判断是否为合法的变量名，

print('a'.islower())#判断是否小写 ，

print('A'.isupper())#判断是否大写，

print(''.isnumeric())#判断是否是数字，必须整数 ，

print(' '.isspace())#判断是否是空格 ，

print('My Name Is '.istitle())#判断每个首字母大写

print('My Name Is' .isprintable())#判断打印字符串，tty设备 file，drive file 无法打印

print('+'.join(['','','','']))#可以使用+号逗号隔开字符串， 连接 参加

print(name.ljust(50,'*'))#长度50不够用*号补充，字符串在左边 ，

print(name.rjust(50,'-'))#长度50不够用-号补充,字符串在右边

print('Alex'.lower())#所有改为小写，

print('Alex'.upper())#所有改为大写，

print('\nAlex'.lstrip())# 去掉左边的空格和回车，

print('Alex\n'.rstrip())# 去掉右边的空格和回车，

print('   Alex\n'.strip())# 去掉空格和回车，

print('---')

p = str.maketrans('abcdef','')#转换的意思

print("xiaaaaa".translate(p))#将对应的字母翻译成数字，

print('alex li'.replace('a','A',1))#将第一个小写a改成大写A,

print('alex li'.rfind('l'))#返回最右边的值下标

print('alex lil'.split())#以空格分割为字符串，

print('1+2+3+4'.split('+'))#以+号分割字符串

print('1+2\n+3+4'.splitlines())#以\n为分隔符

print('Alex Li'.swapcase())#大写转小写，小写转大写，

print('alex li'.title())#首字母大写

print('lex li'.zfill(50))#50字符不够用0填充左边

字符串无参数创建空字符串，一个参数创建普通字符串，两个参数，int（字节，编码）

字符串格式化

name='''

name='zhangchao'

name2=name

print('my name is',name , name2)

name='wangchao'

print (name)

'''

print (name)

Name=input('name:')

Age=int(input('age:'))

print(type(Age), type(str(Age)))

Job=input('job:')

Salary=input('salary:')

#  %s(字符串的占位符,全部类型都可以接收),字符串里面有占位符时必须使用两个%%才能表示一个%号.

#  .format(字符串格式化方法，使格式化的意思)

#  3个引号连接打印的意思

#    %d只能接收整数数字

# %f 接收小数,如不是小数也不会报错,会自动在末尾加小数

info='''

----------info of %s------

Name:%s

Age:%s

Job:%s

Salary:%s

'''%(Name,Name,Age,Job,Salary)

print(info)

name = "Tom"

print ("Hello %s" % name)#打印格式化字符串，把name变量的内容替换到%s处

info2='''

----------info of {_Name}------

Name:{_Name}

Age:{_Age}

Job:{_Job}

Salary:{_Salary}

'''.format(_Name=Name,

           _Age=Age,

           _Job=Job,

           _Salary=Salary)

print(info2)

info3='''

----------info of {0}------

Name:{0}

Age:{1}

Job:{2}

Salary:{3}

'''.format(Name,Age,Job,Salary)

print(info3)

s = 'i am %(n1)s  age %(n2)d '% {'n1':'zc','n2':19}#给位置设置名字

print(s)

s = 'i am %.3f sfsasas' % 1.2

print(s)#保留小数,打印1.200

class foo(object):#面向对象里面的自动调用

    def __str__(self):

        return 'aaa'

    def __repr__(self):

        return 'bbb'

s = 'i am %s, age %d' % (foo(),18)

s = 'i am %r, age %d' % (foo(),18)

print(s)#输出aaa,输出bbb

s = 'i am %c' % (6)

print(s)#输出i am ,转化为uncode码

s = 'i am %o %x' % (6,15)#整数转为8进制,16进制

print(s)

s = 'i am %e ' % (6)#转为科学计数法

print(s)

format格式化:

tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')

print(tpl)#输出i am seven, age 18, alex

tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])

print(tpl)#输出i am seven, age 18, alex

tpl = "i am {0}, age {1}, really {0}".format("seven", 18)

print(tpl)#输出i am seven, age 18, really seven

tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])

print(tpl)#输出i am seven, age 18, really seven

tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)

print(tpl)#输出i am seven, age 18, really seven

tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})

print(tpl)#输出i am seven, age 18, really seven

tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])

print(tpl)#输出i am 1, age 2, really 3

tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)

print(tpl)#输出i am seven, age 18, money 88888.100000

tpl = "i am {:s}, age {:d}".format(*["seven", 18])

print(tpl)#输出i am seven, age 18

tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)

print(tpl)#输出i am seven, age 18

tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})

print(tpl)#输出i am seven, age 18

tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

print(tpl)#输出numbers: 1111,17,15,f,F, 1587.623000%

tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

print(tpl)#输出numbers: 1111,17,15,f,F, 1587.623000%

tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)

print(tpl)#输出numbers: 1111,17,15,f,F, 1500.000000%

tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

print(tpl)#输出numbers: 1111,17,15,f,F, 1500.000000%

字典操作

字典的的索引就是它的键，无法切片，循环默认输出为key

info={

    '':'',

    '':'',

    '':'',

}

print(info)#打印字典

print(info.get(''))#建议安全的查找方法，有，返回，没有，为none

print(info.get(''，''))#若1不存在将显示1111

print (info[''])#查找，有查找，没有报错

print(''in info)#python3查找有返回为真，意思与下相同

#print(info.has_key('1'))#Python2查找，意思与上相同

info['']='张超'#修改字典

info['']='张超'#修改，没有的话添加

#del #python内置通用删除方法，

del info ['']#删除

info.pop('')#删除

info.popitem()#随机删除

av_catlog = {

    "欧美":{

        "www.youporn.com": ["很多","一般"],

        "www.pornhub.com": ["也很大","质量"],

        "letmedothistoyou.com": ["多是自拍"],

        "x-art.com":["很高,请绕过"]

    },

    "日韩":{

        "tokyo-hot":["不清楚,"]

    },

    "大陆":{

        "":["全部","慢"]

    }

}

av_catlog['大陆'][''][1]='快'#修改字典的多级菜单

av_catlog.setdefault('大',{'www.1.com':[1,2]})#在整个字典中取‘大’能取到就返回，无法取到键就创建新的，

print (av_catlog)

dict = { 1 : 2, 'a' : 'b', 'hello' : 'world' }

print (dict.values())#返回所有值

print (dict.keys())##返回所有键

print (dict.items())#遍历整个字典列表并字典转换列表

info ={

    1:2,

    2:3,

    'nihao':'buhao'

}

b={

    'n':'Aluex',

    1:2,

    2:3

}

info.update(b)#合并两个字典，没有重复值就加进去，有重复就覆盖

print(info)

c=dict.fromkeys([3,4,5],[1,{'name':1},1])#中括号是key,对应取所有同一值,初始化一个字典

print (c)

c[3][1]['name']='张超'#修改字典，因三个key共享一个内存地址，如果有多层会全部更改

print(c)

for i in a:

    print (i,a[i])#字典循环使用这种更高效

for k,v in a.items():#字典循环，数据量大非常慢，会将字典转换为列表耗时

    print(k,v)

#字典创建

a={'k1':'v1'}

a=dict(k2=123,k3=234)

print(a)

li=[11,22,33]

new=dict(enumerate(li,10))

print(new)

列表操作（切片/增删改查）

m=['zc',['zc1','zc2',['zc3']]]#列表嵌套，解析

def printm(listin):

    for i in listin:

        if isinstance(i,list):#(判断某个对象是否是某个类创建的)，例子

            printm(i)

        else:

            print (i)

printm(m)

names=['zhangchao','zhnagyang','zhangpan']#列表

names.append('lichao') #append  追加列表值

names.insert(1,'wangchao')#插入列表值，在哪个位置插入加位置序号

names[1]='liuchao'# 改列表中序号1的值

names.remove('liuchao')#删除列表中的值

del names[1]#删除列表中的值

names.pop()#删除列表中的最后一个值

del names[1]=names.pop(1)# 效果相等

print(names.index('huchao'))#查找到位置序号

print( names[names.index('huchao')])#查找到

print(names.count('huchao'))#计数

names.reverse()#反转，头尾反转，

names.clear()#清空列表

names.sort()#按照ASSIC码排序

names.extend(names2)#扩展，合并另一个列表 ,

print(names[:3])=print(names[0:3])#效果相等

print(names[-2:])#切片倒数1,2值

print(names[0:3])#切片0,1,2值，顾头不顾尾

print(names[-3:-1])#切片倒数2,3值

import copy #导入深copy模块

names=['zhang1','zhang2','zhang3',['nihao','nihao2'],'zhang4','zhang5']

names2 = copy.deepcopy(names) #将names列表复制一份赋值names2 ，深copy，（深copy需要导入copy模块deepcopy函数）

names2=names.copy() # 将names列表复制一份赋值names2 ，是浅copy（浅copy不用导模块）

names[3][0] = 'NIHAO' #修改列表中嵌套列表的值

print (names[0:-1:2]) #打印列表全部，步长值2（偶数执行全部），

print (names[::2])  #打印列表全部，步长值2

print (names[:])   #打印列表全部

for i in names:

    print (i)     # 列表for循环

person=['names',['a',100],'张超']

p1=copy.copy(person)#第一种浅copy

p2=person[:]#第二种浅copy

p3=list(person)#第三种浅copy,格式工厂

#创建元祖

t=(1,2,3,'zc')

t=tuple((1,2,3,'zc'))

t=tuple([])#嵌套字符串，列表，字典

#元祖嵌套（内在元素不可修改，但元素的元素可能可以修改，如嵌套的是其它类型就可修改）

t=('zc',11,['张超',{'k1':11}])

t[2][1]['k2']=22#第一种追加方法

print(t)

t[2][1].update({'k3':111})#第二种追加方法

print(t)

集合操作set

无序且不重复的集合, 基本功能包括关系测试和消除重复元素

创建空集合两种方式：S=set()  ，   s={11,222,11,222}     s={} 默认类型为字典

集合转换：l=[11,11,22]， l=(11,44,44)，l=''，print(set(l))

list_1=[1,2,3,45,3]

list_1=set(list_1)

list_2=set([1,2,3,45,54,66])

print (list_1,list_2,type(list_1))

print(list_1.intersection(list_2))#交集,(交接，)，两个都存在的取出来

print(list_1.intersection_update(list_2))#取交集把自己也更新成交集

print(list_1.union(list_2))#并集，(结合)，两个表合并去重

print(list_1.difference(list_2))#差集,(差异)1里面有2里面没有的取出来,以1为主

print(list_2.difference(list_1))#差集,(差异)2里面有1里面没有的取出来，以2为主

print(list_1.difference_update(list_2))# 1里面有2里面没有的取出来,以1为主

更新自己，为None

list_3 = set([1,2,3])

list_4 = set([4,5,6,2])

print(list_1.issubset(list_2))#子集(一部分，)

print(list_1.issuperset(list_2))#父集(超集)

print(list_3.issubset(list_1))#子集

print(list_1.issuperset(list_3))#父集

print(list_1.symmetric_difference(list_2))#对称差集，(相称的，)取出两个列表中互相都没有的，放在一起

print(list_1.symmetric_difference_update(list_2))# 取出两个列表中互相都没有的，更新给自己

print('-------')

print (list_3.isdisjoint(list_4))# 没有交集(不相交的,)两个列表没有交集返回True,有交集返回False

#关系测试符号

print (list_1 & list_2)#交集

print (list_1 | list_2)#并集

print (list_1 - list_2)#差集

print (list_1 ^ list_2)#对称差集

list_1.add(999)#增加单个集合

list_1.update([1,12,223,34]#多个集合，给list_1增加

#list_1.remove(1)#删除list_1中的1，如果不存在将报错

#print (list_1.pop())#随机删除

#print (list_1.discard(2222))#删除，(抛弃，)不存在也不会报错，执行完不返回

print (list_1)

练习：

old_dict={

    '#1':11,

    '#2':22,

    '#3':100,}

new_dict={'#1':33,

          '#4':22,

          '#7':100,}

old_keys=old_dict.keys()

new_keys=new_dict.keys()

old_set=set(old_keys)

new_set=set(new_keys)

del_set=old_set.difference(new_set)

print(del_set)

add_set=new_set.difference(old_set)

print(add_set)

update_set=old_set.intersection(new_set)

print(update_set)

name='zc' if 1==1 else 'zc0'

print(name)

assert_all=0 #(资产)

li=input('请输入总资产:')

assert_all=int(li)

goods=[

    {'name':'电脑','price':1999},

    {'name':'鼠标','price':10},

    {'name':'游艇','price':20},

    {'name':'美女','price':998},]

for i in goods:

    print(i['name'],i['price'])

car_dict={}

while True:

    i2=input('请选择商品(Y/y结算)：')

    if i2.lower()=='y':

        break

    for item in goods:

        if item['name']==i2:

            name=item['name']

            if name in car_dict.keys():

                car_dict[name]['number']=car_dict[name]['number']+1

            else:

                car_dict[name]={'number':1,'single_price':item['price']}

print(car_dict)

all_price=0#总价

for k,v in car_dict.items():

    n=v['single_price']

    m=v['number']

    all_sum=m*n

    all_price=all_price+all_sum

if all_price>assert_all:

    print('你个穷逼这点钱毛的买不到')

else:

    print('你是大款购买成功了')

product_list = [ #产品

    ('iphone',6000),

    ('mac pro',10000),

    ('bike',800),

    ('watch',12000),

    ('coffee',30),

    ('zhangchao',29),

]

shopping_list = []#定义空列表，存取商品

salary = input('input your salary:')#输入工资

if salary.isdigit():#判断工资是不是十进制数字，计算机用二进制，生活中用十进制

    salary = int(salary)#如果是数字，给成整型

    while True:#进入死循环

        for index, item in enumerate(product_list):#取出下标，列举，

            #print(product_list.index(item),item)取下标

            print(index,item)#打印商品列表

        user_choice = input('选择要买什么：')#输入要买的东西，选择，

        if user_choice.isdigit():#判断用户输入的是不是数字类型

             user_choice =int(user_choice)#如果是数字，转成整型

             if user_choice < len(product_list) and user_choice >=0:#判断用户选择商品序号长度小于列表长度并且大于等0

                 p_item = product_list[user_choice]#通过下标把商品取出来

                 if p_item[1] <=salary:#判断是否买的起，如果小于当前工资就买的起

                     shopping_list.append(p_item)#能买的起添加到商品列表中

                     salary -= p_item[1]#扣钱

                     print('Added %s into shopping cart,your current balance is \033[31;1m%s\033[0m' %(p_item,salary) )#买的起打印这句话,

                 else:

                     print('\33[41;1m你的余额只剩下[%s]啦,\33[0m'% salary)#买不起打印

             else:

                 print ('product code [%s] is not exist'% user_choice)#输入的商品序号不存在

        elif user_choice=='q':#如果是q就打印已经买的东西

            print ('----shopping_list------')#打印已经输出的列表

            for p in shopping_list:

                print(p)

            print ('you current balance',salary)#打印剩下的余额

            exit()#退出

        else:

            print('invalid option')#如果不是q打印错误选项(invalid,无效，)(option,选项，)

else:

    print ('invalid option')#开始输入的不是数字打印

data = {

    '北京':{

        '朝阳':{'群众':['大妈','大爷'],'群众1':['大妈1','大爷1']},

        '*':{'国旗':{'旗杆','旗台'},'国旗1':{'旗杆1','旗台1'}},},

    '山东':{'德州':{},},

    '广东':{'东莞':{},}}

exit_flag = False #退出标识(flag标识.  exit退出，)

while not exit_flag:#首先开始循环，not False 为True

    for i in data:#打印第一级

        print(i)

    choice = input('选择进入：')

    if choice in data:#判断是不是在字典里

        while not exit_flag:#在字典里面继续循环

            for i2 in data[choice]:#打印第二层

                print ('\t',i2)

            choice2 = input('选择进入：')

            if choice2 in data[choice]:#判断是不是在字典里

                while not exit_flag:#在字典里面继续循环

                    for i3 in data[choice][choice2]:  # 打印第三层

                        print('\t\t', i3)

                    choice3 = input('选择进入：')

                    if choice3 in data[choice][choice2]:##判断是不是在字典里

                        for i4 in data[choice][choice2][choice3]:# 打印第四层

                            print('\t\t',i4)

                        choice4 = input('最后一层，按b返回:')

                        if choice4 =='b':#返回上一层

                            pass#占位，代码不出错，会返回本层while循环

                        elif choice4 =='q':#判断是否退出

                            exit_flag = True#如果退出 exit_flag=True

                    if choice3 =='b':

                        break

                    elif choice3 == 'q':

                        exit_flag = True

            if choice2 == 'b':

                break

            elif choice2 == 'q':

                exit_flag = True

    else:

        print('输入不存在')

        exit()

    if choice == 'b':

        break

    elif choice == 'q':

        exit_flag = True