Python基础之数据类型

 一、运算符

　　1、算术运算：

　　2、比较运算符:

　　3、复制运算符：

　　4、逻辑运算：

　　5、成员运算：

　　6、三元运算：

result = 值1 if 条件 else 值2

 二、基本数据类型

　　1、数字

　　2、布尔值

　　3、长整型

　　4、复数　　

三、字符串

strip,lstrip,rstrip
lower,upper
startswith,endswith
format的三种玩法
split,rsplit
join
replace
isdigit

#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#lower,upper
name='egon'
print(name.lower())
print(name.upper())

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分

#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())

find,rfind,index,rindex,count
center,ljust,rjust,zfill
expandtabs
captalize,swapcase,title
is数字系列
is其他

#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs
name='egon	hello'
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

#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())

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果

# 7)    将 name 变量对应的值变小写,并输出结果

# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
name = ' aleX'
a=name.strip()
print(a)

# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

name=' aleX'
if name.startswith(name):
    print(name)
else:
    print('no')

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

name=' aleX'
if name.endswith(name):
    print(name)
else:
    print('no')

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
name=' aleX'
print(name.replace('l','p'))

# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
name=' aleX'
print(name.split('l'))

# 6)    将 name 变量对应的值变大写,并输出结果

name=' aleX'
print(name.upper())

# 7)    将 name 变量对应的值变小写,并输出结果

name=' aleX'
print(name.lower())

# 8)    请输出 name 变量对应的值的第 2 个字符?
name=' aleX'
print(name[1])

# 9)    请输出 name 变量对应的值的前 3 个字符?
name=' aleX'
print(name[:3])

# 10)    请输出 name 变量对应的值的后 2 个字符?

name=' aleX'
print(name[-2:])

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

name=' aleX'
print(name.index('e'))

# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
name=' aleX'
a=name[:-1]
print(a)

四、列表

　　序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。　　

list1 = ['李易峰','张艺兴','潘粤明','王思聪','古巨基']

# 正向步长
print(list1[0:3:1])    # list1 = ['李易峰','张艺兴','潘粤明']
# 反向步长
print(list1[2::-1])    # list1 = ['潘粤明','张艺兴','李易峰']
# 列表翻转
print(list[::-1])        # list1 = list1 = ['古巨基','王思聪','潘粤明','张艺兴','李易峰']

五、元祖

　　Python的元组与列表类似，不同之处在于元组的元素不能修改。　　　

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
tuple1=('李易峰','张艺兴','潘粤明','王思聪','古巨基')
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
# print(tuple1[0:5:1])   # 正向取值结果：('李易峰', '张艺兴', '潘粤明', '王思聪', '古巨基')
print(tuple1[5::-1])     # 反向取值结果：('古巨基', '王思聪', '潘粤明', '张艺兴', '李易峰')
#2、长度
print(len(tuple1))      # 5
#3、成员运算in和not in
result1 = '李易峰' in tuple1
print(result1)  # True
result = '李易峰' not in tuple1
print(result)   # False
#4、循环
for i in tuple1:
    print(i)

# 练习简单购物车,要求如下：

# 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入

print('欢饮光临，本店供应如下商品，请选购！')
msg_dic={'apple':10,'tesla':100000,'mac':3000,'lenovo':30000,'chicken':10,}
goods_list = []
while True:

    for key,item in msg_dic.items():

        print('goods_name:{name}     goods_price:{price}'.format(name=key,price=item))
    choice = input('请输入商品：').strip()
    if not choice or choice not in msg_dic:
        print('商品名输入错误，请重试！')
        continue
    count = input('请输入个数:').strip()
    if not count.isdigit():continue
    goods_list.append((choice,msg_dic[choice],count))
    print(goods_list)
    print('购买成功，欢迎下次光临！')
    break

 六、字典

　　作用：存多个值，key/value存取，取值速度快！　　

# 常用语法
info={'name':'李易峰','age':31,'gender':'male'}
info1=dict(name='李易峰',age=31,gender='male')
info2=dict([['name','李易峰'],('age',31),('gender','male')])

# 1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)
# 2、统计s='hello alex alex say hello sb sb'中每个单词的个数
s='hello alex alex say hello sb sb'
list1=s.split()
dic={}
for item in list1:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)
# 3、其它做法（setdefault用法）
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
print(words)
for word in words: #word='alex'
    dic[word]=s.count(word)
    print(dic)

#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #1
d={'a':2222}
print(d.setdefault('a',1)) #2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)

#利用集合，去掉重复，减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

七、集合

　　作用：去重，关系运算
　　定义集合：集合可以包含多个元素，用都好分割。

　　集合元素遵循的三个原则：

　　　　a.每个元素必须是不可变类型（可hash，可作为字典的key）

　　　　b.没有重复的元素

　　　　c.无序

　　注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无序纠结于集合中单个字

# 一.关系运算
# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)         # {'wupeiqi', 'gangdan'}
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)         # {'yuanhao', 'gangdan', 'alex', 'oldboy', 'biubiu', 'egon', 'wupeiqi'}
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)         # {'yuanhao', 'egon', 'alex', 'biubiu'}
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)         # {'yuanhao', 'alex', 'oldboy', 'biubiu', 'egon'}

# 二.去重
#
# 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
list=['a','b',1,'a','a']
print(set(list))
# 2.在上题的基础上，保存列表原来的顺序
#方法一:不用集合
list=[1,'a','b',1,'a']
l1=[]
for i in list:
    if i not in l1:
        l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in list:
    if i not in s:
        s.add(i)
        l1.append(i)
print(l1)
# 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
import os
with open('db.txt','r',encoding='utf-8') as read_f,
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

# 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
list=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'}
]
s=set()
l1=[]
for item in list:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)
print(l1)

八、数据类型总结

　　按存储空间的占用分（升序）

数字
字符串
集合：无序（即无序存索引相关信息）
元祖：有序（需要存索引相关信息，不可变）
列表：有序（需要存索引相关信息，可变，需要处理数据的增删改）
字典：无序（需要存keyvalue映射的相关信息，可变，需要处理数据的增删改）

九、运算符　　

#身份运算（is ，is not）
# is比较的是id，而双等号比较的是值，id若相同则值肯定相同，而值相同id则不一定相同
x=123456789
y=123456789
# id(x),id(y)
print(x == y)
print(id(x)is id(y))

~