类型转换

纯数字的字符串转成int

res=int('100111')
print(res,type(res))

float类型转换

res=float("3.1")
print(res,type(res))

字符串类型转换

str可以把任意其他类型都转成字符串

res=str({'a':1})
print(res,type(res))

使用：内置方法

按索引取值(正向取+反向取) ：只能取

msg='hello world'
正向取
print(msg[0])
print(msg[5])
反向取
print(msg[-1])

只能取
msg[0]='H'

切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串

msg='hello world'
顾头不顾尾
res=msg[0:5] #x
print(res)
print(msg)
步长
res=msg[0:5:2] # 0 2 4
print(res) # hlo
反向步长(了解)
res=msg[5:0:-1]
print(res) #" olle"
msg='hello world'
res=msg[:] # res=msg[0:11]
print(res)
res=msg[::-1] # 把字符串倒过来
print(res)

长度len

msg='hello world'
print(len(msg))

成员运算in和not in

判断一个子字符串是否存在于一个大字符串中

print("alex" in "alex is sb")
print("alex" not in "alex is sb")
print(not "alex" in "alex is sb") # 不推荐使用

移除字符串左右两侧的符号strip

默认去掉的空格

msg='      egon      '
res=msg.strip()
print(msg) # 不会改变原值
print(res) # 是产生了新值

默认去掉的空格

msg='****egon****'
print(msg.strip('*'))

strip只取两边，不去中间

# msg='****e*****gon****'
# print(msg.strip('*'))

切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

默认分隔符是空格

info='egon 18 male'
res=info.split()
print(res)

指定分隔符

info='egon:18:male'
res=info.split(':',1)
print(res)

strip,lstrip,rstrip

print(msg.strip('*'))
print(msg.lstrip('*'))
print(msg.rstrip('*'))

lower,upper

msg='AbbbCCCC'
print(msg.lower())
print(msg.upper())

startswith,endswith

print("alex is sb".startswith("alex"))
print("alex is sb".endswith('sb'))

split,rsplit:将字符串切成列表

info="egon:18:male"
print(info.split(':',1)) # ["egon","18:male"]
print(info.rsplit(':',1)) # ["egon:18","male"]

join: 把列表拼接成字符串

print(res)l=['egon', '18', 'male']
res=l[0]+":"+l[1]+":"+l[2]
res=":".join(l) # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
print(res)

replace

msg="you can you up no can no bb"
print(msg.replace("you","YOU",))
print(msg.replace("you","YOU",1))

isdigit

判断字符串是否由纯数字组成

print('123'.isdigit())
print('12.3'.isdigit())

字符串了解内容

find rfind 返回的是找到第一个字符串的索引找不到会返回-1

msg='tony say hello'
print(msg.find('n'))

index rindex 返回的是找到第一个字符串的索引找不到会报错

msg='tony say hello'
print(msg.index('a'，2，9))

count 统计字符在字符串中出现的位置

msg='tony say helloooooooo'
print(msg.count('o',1,6))

capatalize 首字母大写

msg='hello everyone nice to meet you'
print(msg.capitalize())

swapace 大小写翻转

msg='Hi girl,I want make friends with you!'
print(msg.swapcase())

title 每个单词首字母大写

msg='dear my friend i miss you very much'
print(msg.title())

添加

append 往列表尾部追加元素

l=[11,22,31]
l.append(2222)
print(l)

**extend 一次性往列表尾部添加多个元素只能添加列表元素 **

l=[111,22,33,2]
l.extend([1111,22222,555])
print(l)

insert 在指定位置插入值

l=[11,222,34,4]
l.insert(1,'qqq')
print(l)

删除

1. del 通用删除没有返回值

l=[111,222,3333]
del l[1]
print(l)

2.pop 默认删除列表最后一个元素，并将删除的值返回，括号内可以按照索引值来删除元素*

l=[1111,22,3,4,2]
# l.pop()
l.pop(2)
print(l)

3.remove 括号内填写要删除的元素，返回值为None

l=[111,222,34,5]
res=l.remove(222)
print(res,l)

**sort 给列表内的元素排序按照升序排列排序必须是同类型的元素，否则报错
默认升序排序 **

l=[111,333,4,2,1]
l.sort()
print(l)

reverse 把列表翻转过来

l=[122,1,3333,2,4]
l.reverse()
print(l)

is数字系列

在python3中

num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

isdigt:bytes,unicode

print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

isdecimal:uncicode

#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

isnumberic:unicode,中文数字,罗马数字

#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

**三者不能判断浮点数

num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())

总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric

is其他

print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

元组

元组与列表相似，可以存放多种类型的值，但是元组不能修改元素属于不可变类型单纯用于取

定义

在()内用逗号分隔开多个任意类型的值

l=(1,2,3,4)

类型转换

print(tuple('casd'))

字典

类型转换

1.
info=dict([['name','tom'],('age',18)])
print(info)

2.fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
dic={}.fromkeys(('name','age','sex'),None)
print(dic)

使用

1.对于赋值操作，如果key原先不存在于字典，则会新增key:value

info={'name':'egon','age':18}
info['sex']='male'
print(info)

2.对于赋值操作，如果key原先存在于字典，则会修改对应value的值

info={'name':'egon','age':'18'}
info['name']='tank'
print(info)

删除
1.pop 通过字典key来删除字典的键值对

info={'name':'egon','age':18}
info.pop('age')
print(info)

键keys（）值valus（）键值对items()

info={'name':'egon','age':18}

获取key

res=info.keys()
print(res)

获取 valuse

res=info.values()
print(res)

获取字典所有键值对

print(info.items())

集合

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

定义

在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1、每个元素必须是不可变类型
2、集合内没有重复的元素
3、集合内元素无序

s={1,2} # s=set({1,2})
s={1,[1,2]} # 集合内元素必须为不可变类型
s={1,'a','z','b',4,7} # 集合内元素无序
s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s)

s={} # 默认是空字典
print(type(s))
定义空集合
s=set()
print(s,type(s))

类型转换

set({1,2,3})
res=set('hellolllll')
print(res)
print(set([1,1,1,1,1,1]))
print(set([1,1,1,1,1,1,[11,222]]) # 报错
print(set({'k1':1,'k2':2}))

内置方法

取交集：两者共同的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
res=friends1 & friends2
print(res)
print(friends1.intersection(friends2))

取并集/合集：两者所有的好友

取并集/合集：两者所有的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
res=friends1 & friends2
print(friends1 | friends2)
print(friends1.union(friends2))

###取差集：取friends1独有的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 - friends2)
print(friends1.difference(friends2))

取friends2独有的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends2 - friends1)
print(friends2.difference(friends1))

###对称差集: 求两个用户独有的好友们

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 ^ friends2)
print(friends1.symmetric_difference(friends2))

###父子集：包含的关系

s1={1,2,3}
s2={1,2,4}
print(s1 > s2)
print(s1 < s2)

##去重
只能针对不可变类型去重

print(set([1,1,1,1,2]))

无法保证原来的顺序

l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l)

###长度

s={'a','b','c'}
len(s)

###成员运算

'c' in s

##其他内置方法
###需要掌握的内置方法1：discard

s.discard(4) # 删除元素不存在do nothing
print(s)
s.remove(4)# 删除元素不存在则报错

###需要掌握的内置方法2：update

s.update({1,3,5})
print(s)

###需要掌握的内置方法3：pop

res=s.pop()
print(res)

###需要掌握的内置方法4：add

s.add(4)
print(s)

作业

name=' aleX'

移除 name 变量对应的值两边的空格,并输出处理结果
new_name=name.strip()
print(new_name)
判断 name 变量对应的值是否以 "al" 开头,并输出结果
name1=name.startswith('al')
print(name1)
判断 name 变量对应的值是否以 "X" 结尾,并输出结果
print(name.startswith('X'))
将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l','p'))
将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.rsplit('l'))
将 name 变量对应的值变大写,并输出结果
print(name.upper())
将 name 变量对应的值变小写,并输出结果
print(name.lower())
请输出 name 变量对应的值的第 2 个字符?
print(name[1])
请输出 name 变量对应的值的前 3 个字符?
print(name[:3])
请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
请输出 name 变量对应的值中 “e” 所在索引位置?
print(name.index('e'))
获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name[:-1])

7.13 作业

1、有列表info=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

name=info[0]
age=info[1]
year=info[2][0]
mon=info[2][1]
day=info[2][2]

2、用列表的insert与pop方法模拟从列表的一端存值，然后从另外一端取值

l=[]
l.insert(0,'abc')
l.pop()

3. 用列表的insert与pop方法模拟从列表的一端存值，然后从另外一端取值

l=[]
l.insert(-1,'bbb')
l.pop(0)

4、简单购物车,要求如下：
实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数以三元组形式加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
tag=True
l=[]
su=0
pic=0
while tag:
    for x,y in msg_dic.items():
        print('商品名：{name}&&价格：{price}'.format(name=x,price=y))
    chioce=input('请输入你要购买的商品名：').strip()
    if chioce in msg_dic:
        count=input('请输入你要买的商品的数量：').strip()
        count=int(count)
        pic=int(msg_dic[chioce])*count
        cmd=input("是否继续购物，如果是请输入’Y'，否则按任意键退出。请输入指令》》：")
        if cmd=='y' or cmd=='Y':
            print('欢迎继续购物！')
        else:
            print('欢迎下次光临！')
            tag=False
    else:
        print('请输入正确的商品名！')
        continue
    if  pic not in msg_dic and count not in msg_dic:
        l.append((msg_dic[chioce],count,pic))
        su+=pic
print('消费明细如下：{}'.format(l))
print('共消费：{}'.format(su))

5、有如下值集合 l=[11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

l=[11,22,33,44,55,66,77,88,99,90]
dic={'k1':[],'k2':[]}
for x in l:
    if x>66:
        dic['k1'].append(x)
    else:
        dic['k2'].append(x)
print(dic)

6、统计s='hello alex alex say hello sb sb'中每个单词的个数

s='hello alex alex say hello sb sb'
d={}
s=s.split(' ')
for x in s :
    if  x not in d:
        d[x]=s.count(x)
print(d)

基本数据类型

基本数据类型

类型转换

纯数字的字符串转成int

float类型转换

字符串类型转换

使用：内置方法

按索引取值(正向取+反向取) ：只能取

切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串

长度len

成员运算in和not in

移除字符串左右两侧的符号strip

切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

strip,lstrip,rstrip

lower,upper

startswith,endswith

split,rsplit:将字符串切成列表

join: 把列表拼接成字符串

replace

isdigit

字符串了解内容

添加

删除

is数字系列

is其他

元组

定义

字典

使用

集合

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

定义

类型转换

内置方法

取交集：两者共同的好友

取并集/合集：两者所有的好友

作业

7.13 作业