Python是个啥-第三章数据类型

第三章 数据类型

3.1 整型（integer/int）

3.1.1 整型的长度

  • 32位电脑整形的取值范围（-2xx31-----2xx31）
  • 64位电脑整形有取值范围（-2xx63~2xx63）
  • py2中有：int/long
  • py3中有：int （int/long）

3.1.2 整除

py2和py3中整除是不一样。

  • py2：整形做除法运算，是显示整数部分

    from __future__ import division  #运算前提前加上这句才能显示小数
a=7/2
print(a)

  • py3：整形的除法保留所有

    a=7/2
print(a)

3.2 布尔（bool）

布尔值就是用于表示真假。True和False。

其他类型转换成布尔值：

  • str
  • ...

对于：None / "" / 0 .... -> False，其他都是Ture。

3.3 字符串（str/string）

字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储。对于字符串是不可变。

一般都用‘ ’，“ ”，''' ''',"" ""表示，单引号，双引号，三个单引号，三个双引号.

空字符串写法：

x=''
x=""
x=""""""
x=''''''

3.3.1字符串独有方法

  • upper #大写

    v = 'allen'
v1 = v.upper()
print(v1) #ALLEN
v2 = v.isupper() # 判断是否全部是大写
print(v2)

  • lower #小写

    v = 'allen'
v1 = v.lower()
print(v1)
v2 = v.islower() # 判断是否全部是小写
print(v2)

############ 了解即可
v = 'ß'
v1 = v.casefold() # 将字符串变小写（casefold另一种方法）
print(v1) # ss
v2 = v.lower()
print(v2) # ß

  • isdigit #判断是否是数字

    v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit()  # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumluciffer() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 以后推荐用 isdecimal 判断是否是 10进制的数。

# ############## 应用 ##############

v = ['allen','luciffer','tony']

for i in v:
    print(i)

num = input('请输入序号：')
if num.isdecimal():
    num = int(num)
    print(v[num])
else:
    print('你输入的不是数字')

  • strip #去空白 +\t+\n + 指定字符串

    na
v1 = "allen "
print(v1.strip())

v2 = "allen\t"
print(v2.strip())

v3 = "allen\n"
print(v3.strip())

v1 = "allena"
print(v1.rstrip('a')) #去掉指定字符串，右边的a

  • replace ("被替换","替换",1) #替换

    'A18me'.replace('18','BC',1) #字符替换

  • 开头 / 结尾 startwith/endwith

    v1 = "allena"
print(v1.startswith('a'))
print(v1.endswith('b'))

  • encodde #编码，把字符串转换成二进制

    a='中国Abc'
print(a.encode('utf-8'))  #b'\xe4\xb8\xad\xe5\x9b\xbdAbc'

  • format /format_map#格式化

    a='有{0}，就是{1}'.format('钱','任性')
print(a)
a='有{}，就是{}'.format('钱','任性')
print(a)
a='有{a2}，就是{a1}'.format(a2='钱',a1='任性')
print(a)

  • join #字符串连接

    print('+'.join(['1','2','3','4p'])) #列表中的值用+连接
#1+2+3+4p

  • split #以什么转换为列表，

    x="print('abc123'.123isprintable())123达特"
d=x.split('123') #以123位分隔符，转换字符串位列表
print(d)

3.3.2 字符串其他方法

print(name.count('l')) #查找l的个数
print(name.center(50,"-")) #居中，不足的用-补齐，长度50字符
print(name.endswith('n'))  #g   end
print(name.expandtabs(tabsize=20))  #tables键转换成20个字符
print(name.find('allen'))#allen是第几个字符
print(name.index('name')) #查找位置
#print('123'.isdigit())  #整数判断
print('abc123'.isalnum())#判断 英文字符和数字，不包含特殊字符
print('abc'.isalpha())#判断纯字符
print('1A'.isdecimal())#判断是不是10进制
print('10'.isdecimal())#判断是不是10进制
print('abc123'.isidentifier())#合法变量判断（标识符）
print('A 1 a'.islower()) #是不是小写
print('My Name Is 12B'.istitle())  #是不是taital类型，首字母大写
print('abc123'.isprintable())#是不是打印设备，tty文件就不是
print('-------------')
name='abcde'
c="_".join(name)  #用_拼接name a_b_c_d
print(c)
#print('+'.join(['1','2','3','4p'])) #列表中的值用+连接
print(name.ljust(50,'^'))
print(name.rjust(50,'^'))  #凑够50个字符向右打印，不够的字符放在左边用^补齐
print(name.upper()) #字符转换为大写
print(name.lower()) #字符转换为小写
print('-------------')
print('\nzHANG1'.lstrip()) #去掉左边的空格和换行
print('\nzHANG1\n'.rstrip()) #去掉右边的空格和换行
print(' \nzHANG\n '.strip()) #去掉两边的空格和换行
print('-------------')
p=str.maketrans('abcdef','123456')
print('abcdefghijklmnaaaaa'.translate(p))  #将abcdef转换成123456对应的单一字符替换
print('A18me'.replace('18','BC',1)) #字符替换
print('A18m1e'.rfind('1'))#找到最右边的1的下标值
print('A+E+7+1E+9'.split('+')) #字符串转换为列表，并制定以+区分
print('A+E+7+1E+9'.split('E')) #字符串转换为列表，并制定以E区分
print('A+E+7+1E+9a'.swapcase()) #大小写转换
print('aA+e+me7+1E+9io'.title()) #转换为标题格式
print('10E'.zfill(8))  #用0补齐10个字符，16进制用到

3.3.3案例

登录界面中的验证码模拟，输入的内容不区分大小写。

#使用案例：验证码（不区分大小写）
check_out='I7x1'  #验证码
flag=True
while flag:
    check_in=input('Please inlut code %s:'%check_out)  #输入的验证码
    if check_in.lower() == check_out.lower():
        print("Welcome Login in.")
        flag=False
    else:
        print("Sorry,Please try.") #字符换转换

3.4 列表

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

使用范围：表示多个事物的时候使用。

格式：['user1','user2']

空列写法：

x=[]
x=list[]

3.4.1 列表的独有方法

  • append() 列表最后添加元素

    names=[]
flags=0
while flags <3:
    user_input=input('Input your name:')
    names.append(user_input)
    flags+=1
print(names)

  • insert() #插入到指定位置

    users=['a', 'b', 'c']
users.insert(2,'d')
print(users)

  • remove() 删除内容 ，删除元素如果元素不存在则会报错

    users=['a', 'b', 'c']
users.remove('c')

  • pop() 删除索引位置

    users=['a', 'b', 'c']
users.pop(2)
users['a','dda',2,3,4,5,7]
users.pop(1)  #(索引值) 注意索引值（）
del users[1]   #[索引值]  注意【】

  • clear 清空

  • extend #列表合并

  • 删除（数字、字符串、布尔值除外）

  • reverse 反转

  • sort 排序

    a=[1,3,19,28,2]
a.reverse()
# a.sort()
print(a)

users=['a', 'b', 'c',['aa','bb','cc'],True,2,3]
u1=users[0]
u2=users[3][0]
u3=users[4]
print(u1,u2,u3)

3.4.2 案例

3.5 元组

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

格式：tuple元组使用小括号（）

3.5.1 元组独有方法（无）

3.5.2案例

3.6 字典

Python字典是另一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型。

3.6.1字典格式

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

data = {key1 : value1, key2 : value2 }

​ 注意：键必须是唯一的，但值则不必；值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

也可如此创建字典

3.6.2 字典独有方法

  • get
info={}
info.get(key)  如果key存在则返回 如果不存在则返回null

info.get(key,'不存在')  #如何key不存在赋给默认值'不存在'
  • pop
info={'name':'allen','age':23,'sex':'Female',}
info.pop('sex')  #pop
print(info)
del info['age'] #del
print(info)
  • update（如果有更新，如果没有创建）
info={'name':'allen','age':23,'sex':'Female',}
info['coust']=100  #添加
info.update({'allen':1,'iver':22})  如果有更新，如果没有创建
print(info)
  • keys/values/items
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
#字典套字典,字典套列表
dict3={
	'name1':"alice",
    'name3':{'age':12},
	'name2':{
        'age':[13,14],
    },
}
v1=dict3.keys() #获取keys
v2=dict3.values() #获取values
v3=dict3.items() #获取所有键值对

3.6.3 案例

创建一个购物车，并对购车里面的商品进行增删改查，用字典实现。

#__Author:  Playon
#__Date:    2016/3/12 12:05
#-*- coding:utf-8 -*-
product={
    '苹果':'6',
    '栗子':'25',
    '鸡蛋':'2.5',
    '花菜':'26',
    'phone':'6000',
    'pen':'16',
}
def price():
    #price change
    choice = input('Please input change goods:')
    if choice in product:
        price_new=input('Please input %s new price:'%choice)
        product[choice]=price_new
    else:
        print('Goods %s do not exist!'%choice )

def goods_add():
    #goods add
    choice = input('Input new goods name:')
    price = input('Input new goods price:')
    if choice in product:
        print(choice ,'existed')
    else:
        product[choice]=price
def goods_del():
    # goods del
    choice = input('Input delete goods:')
    if choice in product:
        del product[choice]
    else:
        print('%s not existed!')

while True:
    num = 1  #定义商品序号从1开始
    for goods in product:

        print('\033[1;34;m%s.%s\t\t%s\033[0m'%(num,goods,product[goods])) #按照指定格式打印商品
        num +=1
    #选择操作类型
    choice_plan= input(
"""\033[0;33;m############## 请选择 ################
#       a---添加商品选择 a            #
#       e---编辑商品选择 e            #
#       d---删除商品选择 d            #
#       q---退出系统选择 q            #
#####################################\033[0m""")
    if choice_plan == 'a':
        goods_add()
    elif choice_plan == 'e':
        price()
    elif choice_plan == 'd':
        goods_del()
    elif choice_plan == 'q':
        break
    else:
        print('Choice Error!')
        continue

3.7 集合

  • 特点：天生去重，无序
  • 格式：v={1,2,3,4,5,6} 、 set{}
  • 注意事项：
    • 不能作为key来存放的类型（列表、字典、集合等可变类型）【unhashable错误】，因为内部会将一个值进行hash计算对应，用于快速查找。
    • True和False在列表中对应的是1和0，则true和1不会同时存在。

3.7.1 集合独有方法

  • add 添加

    v={1,2,3,4,5,6,7,'allen',(1,2,3,),}
v.add('Alice')
print(v)  #{1, 2, 3, 4, 5, 6, 7, 'allen', 'Alice', (1, 2, 3)}

  • discard 删除

    v={1,2,3,4,5,6,7,'allen',}
v.discard('allen')
print(v)  #{1, 2, 3, 4, 5, 6, 7}

  • update 更新

    v={1,2,3,4,5,6,7,'allen'}
v1={1,'2','Allen',}
v.update(v1)
v.update('allen')  #allen会被拆分
print(v)
#{1, 2, 3, 4, 5, 6, 7, '2', 'l', 'e', 'allen', 'a', 'Allen', 'n'}

  • intersection() 交集

  • union() 并集

  • difference() 差集

  • symmetric_difference() 对称差集

3.7.2 案例

集合和列表的查询效率测试：千万级/亿级的数据查询效率比较，有个列表和集合，里面分别存放着0~1亿个元素，任意输入一个数字比较是否是列表或集合的元素，并计算时间

import time
flag=True
while flag:
    choice=input('list or set >>') #选择比较的类型，集合或者列表
    if choice == 'list':
        code=[]
        for i in range(100000000): #创建一个100000000元素的列表
            code.append(i)
        break
    elif choice=='set':
        code=set()
        for i in range(100000000): #创建一个100000000元素的集合
            code.add(i)
        break
    else:
        print('input error!')
while True:
    check_num=input('Please Input the number of check(0-100000000):') #输入需要比较的数值
    if check_num.isdigit():
        break
    else:
        continue
def run_time():
    #比较数字是否在code里面
    if int(check_num) in code: 
        print('existed。')
    else:
        print('null')
def times():
    #计算查询的时间
    s=time.time()
    run_time()
    e=time.time()
    run_code1=e-s
    print('%s run time:%ss'%(check_num,run_code1))
times() #执行时间函数

3.8 数据类型公共方法

  • len ，长度

    #字符串
name='luciffer'
len(name) #计算长度

#列表
name=['allen','bill','coke','ada']
len(name)  #获取长度

#元组
name=('allen','bill','coke','ada')
len(name)  #获取长度

#字典
dict3={
	'name':'allen',
	'age':23,
    'sex':'Female',
}
v3=len(dict3)
print(v3)

#集合
v={1,2,3,4}
print(len(v))

  • 索引 ，根据下标获取值

    #字符串
v='allen'
v1=v[0]  # 0 1 2 3 4 5
v1=v[-1] #最右边的下标  -是从右边开始取值-1 -2 -3（注意没有0的事情）

#列表
name=['allen','bill','coke','ada']
name1=name[0]
print(name1)

#元组
name=('allen','bill','coke','ada')
name1=name[0]
print(name1)

#字典
info={'name':'alice','age':'12','school':['cent1','cent2']}
print(info['name'])
print(info['age'])
print(info['school'][0])

#集合（无）

  • 切片，截取内容

    #字符串
v="Iverson 0allen1"
print(v[5:7])  #取on 起始位置到结束位置，列表是取左不取右 所以不取[7]
v[1:-1]  #取到最后不包含最后一个
v[3:]  #取到最后
v[:]  #取全部
v[:-1] #从开头取到最后不包含最后一个

#列表
name=['allen','bill','coke','ada']
val= users[0:2]

#元组
name=('allen','bill','coke','ada')
val= users[0:2]

#字典（无）

#集合（无）

  • 步长，

    #字符串
v="123456789"
v1=v[::-1] #倒序
v2=v[0::2] #下标0开始一直到最后（不包含最后一个），间隔（步长）是2
print(v1)
print(v2)

#列表
name=['allen','bill','coke','ada','abc','def']
val1=name[0::2] #步长2
print(val1)

#元组
name=('allen','bill','coke','ada','abc','def')
val1=name[0::2] #步长2
print(val1)

#字典 （无）

#集合（无）

  • for循环，

    #字符串
x='abcdef'
for i in x:
    print(i) 
    
#列表  #整形拼接   “_”拼接
nums = [11, 22, 33, 44]
for i in range(0,len(nums)):
     nums[i]=(str(nums[i])) #int转换为str
print("_".join(nums)) #11_22_33_44

#元组
nums = (11, 22, 33, 44)
for i in nums:
	print(i)
#11
#22
#33
#44

#字典
dict3={
	'name':'allen',
	'age':23,
    'sex':'Female',
}
for i in dict3：
	print(i)  #默认print KEYS
#--keys
for i in dict3.keys():
    print(i)
#--values
for i in dict3.values():
    print(i)
#--items
for i,x in dict3.items():
    print(x,"----->",i)
print(len(dict3))

#集合
v={1,2,3,4}
for i  in v:
  print(i)

3.9 嵌套

列表嵌套

users=['a', 'b', 'c',['aa','bb','cc'],True,2,3]
u1=users[0]
u2=users[3][0]
u3=users[4]
print(u1,u2,u3)

元组嵌套

users=('a', 'b', 'c',['aa','bb','cc'],True,2,3)
u1=users[0]
u2=users[3][0]
u3=users[4]
print(u1,u2,u3)

字典嵌套

user={1:2,'a':{'name':'alice'},'b':['bb','bbb'],}
for i in user:
    print(user[i])

集合嵌套

3.10 数据类型总结

  • int 整形

  • bool 布尔型

  • str 字符串

  • list 列表

  • tuple 元组

  • dict 字典

  • 案例1.判断敏感字符（str/list/dict）

    #字符串
info='毛东思想'
if '毛东四' in info:
    print('敏感字符')

#列表
info = ['毛东四','小学生','李老六']
if '毛东四' in info:
    print('敏感字符')

#字典
info={'k1':'v1','k2':'v2','k3':'v3'}

#判断k1是否存在
if 'k1' in info:
    print("存在")

#判断v2是否存在
flag='不存在'
for i in info.values():
    if i == 'v2':
        flag='存在'
print(flag)

#判断k3:v3是否存在
value=info.get('k3')
if value=='v3':
    print('存在')

    案例2.综合练习敏感字符

    #1.简单版
list=['网红','big','杀人']  #敏感字符
str_in=input('>>:')
for i in list:
    if i in str_in:
        print('被和谐了')
        break
    else:
        continue
#2.进化版
list=['网红','big','杀人']  #敏感字符
flag=True
str_in=input('>>:')
for i in list:
    if i in str_in:
        flag=False
        break
if flag:
    print(str_in)
else:
    print('被和谐了')
posted @ 2019-07-19 16:16  PlayOn  阅读(96)  评论(0)  编辑  收藏  举报