Python语言系列-02-基础数据类型
格式化输出
#!/usr/bin/env python3
# author:Alnk(李成果)
# 百分号% 格式化输出
name = input('姓名:')
age = input('年龄:')
sex = input('性别:')
hobby = input('爱好:')
job = input('工作:')
msg = '''------------ info of %s -----------
Name : %s
Age : %s
job : %s
hobby: %s
------------- end -----------------''' % (name, name, age, job, hobby)
print(msg)
# 补充：注意其中的一个坑
# 当用格式化输出的时候，里面有百分号，表示百分之几，需要两个百分号转义
msg1 = '我叫%s，今年%s岁，学习进度3%%' % ("alnk", 18)
print(msg1)
# format 格式化输出
# 第一种
msg = '我叫{} 今年{} 性别{}'.format('tom', '18', '男')
print(msg)
# 第二种
msg = '我叫{0} 今年{1} 性别{2}，我依然叫{0}'.format('tom', '18', '男')
print(msg)
# # 第三种
msg = '我叫{name} 今年{age} 性别{sex}'.format(name='tom', sex='男', age='18',)
print(msg)
运算符
#!/usr/bin/env python3
# author:Alnk(李成果)
"""
运算符：
算数运算，逻辑运算，赋值运算，比较运算，位运算，成员运算，身份运算...
算数运算：+ - * / ** // %
比较运算: == < > >= <= !=
赋值运算: = += -= *= /= ....
逻辑运算: and or not
"""
# 一、逻辑运算: and or not
# 优先级：() > not > and > or ,同一优先级从左至右依次计算
# 1,运算符两边全部是比较运算
print(1 > 2 and 3 < 4 and 2 > 7 or 4 < 5) # True
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8) # False
# 2,运算符两边全部是数值
# x or y: if x is True return x else y
print("-" * 20)
print(1 or 3) # 1
print(2 or 3) # 2
print(-1 or 3) # -1
print(0 or 3) # 3
print(1 or 3 or 0 or -1) # 1
# x and y: 和上面相反 if x is True return y else x
print("-" * 20)
print(1 and 3) # 3
print(2 and 3) # 3
print(-1 and 3) # 3
print(0 and 3) # 0
# int ---> bool: 非0即True，0即False
# int ---> bool: True 1，False 0
print("-" * 20)
i = 0
print(bool(i)) # False
print(int(True)) # 1
print(int(False)) # 0
# 3,运算符两边即是比较又是数值
print("-" * 20)
print(1 > 2 or 3 and 4) # 4
# 二、成员运算：in、not in
print("-" * 20)
s1 = "abcde"
s2 = 'ac'
print(s2 in s1) # False
if s2 in s1:
print(333)
else:
print(111) # 111
编码
#!/usr/bin/env python3
# author:Alnk(李成果)
"""
谍战剧： 场景 发电报 滴滴滴滴滴滴滴
计算机：文件的存储或者网络传输 高低电平01010101
密码本：记录的就是010101 与文字的对应关系。
今 0000001
晚 0000101
吃 0000110
鸡 0010001
# 0010101011010001
0000001000010100001100010001
ASCII：最初版本的密码本：英文字母，数字，特殊字符
最开始：
0000 0001 256种可能。
0000 0001 8位 = 1个字节（bytes）。
s1 = 'hello1' 6个字节
一个字节表示一个字符。
h: 01101000
e: 01101001
l: 01101100
o: 01101110
1:
01101000 01101001 01101100 01101100 01101110 01101111
unicode：万国码。把全世界所有的文字都记录起来。
起初：一个字符两个字节
h: 01101000 01101000
中：01101000 01101000
不够用
升级：一个字符四个字节
h: 01101000 01101000 01101000 01101000
中: 01111000 01101000 01101000 01101000
浪费空间，浪费流量
utf-8: 最少用8位一个字节表示一个字符。
英文: 01101000 ASCII 英文字符：1个字节表示
欧洲文: 01101000 01101000 一个字符两个字节表示
中文: 01101000 01101100 01101000 一个字符用3个字节表示。
'old男孩' utf-8的编码方式： 9个字节
gbk:国标。
只包含：英文和本国语言。
h: 01101000 ASCII 英文字符：1个字节表示
中: 01101000 01101100 一个字符用2个字节表示
'old男孩' gbk的编码方式： 7个字节
单位转化：
8bit == 1Bytes
1024Bytes == 1KB
1024KB == 1MB
1024MB == 1GB
1024GB == 1TB
"""
# 1， 不同密码本之间不能互相识别。报错，乱码。
# 2， 数据的存储或者网络传输不能用unicode的密码本进行编码。
#
# python3x 环境：
# str类型内部编码方式为Unicode。
# 所以：str类数据不能直接存储硬盘，或者网络传输。
#
# str: 操作方法
# bytes: 拥有和str相同的操作方式，并且编码为非Unicode
#
# 英文：
# str:
# 表现形式：'alex'
# 内部编码：unicode
#
# bytes:
# 表现形式：b'alex'
# 内部编码：非unicode
#
# 中：
# str:
# 表现形式：'alex'
# 内部编码：unicode
#
# bytes:
# 表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'
# 内部编码：非unicode
#
# 英文
print("---------------英文------------------")
str1 = 'barry' # 字符串
print(type(str1)) # <class 'str'>
print(str1.upper())
# bytes
b1 = b'barry' # bytes字节
print(type(b1)) # <class 'bytes'>
print(b1.upper())
# 中文
print("---------------中文------------------")
s1 = '中国'
print(type(s1)) # <class 'str'>
b1 = s1.encode('utf-8') # 编码
print(type(b1)) # <class 'bytes'>
print(b1) # bytes
# 转换；
# str ---> bytes
print("------------- str ---> bytes -----------")
ss1 = "abc"
print(type(ss1)) # <class 'str'>
ss2 = ss1.encode("utf-8")
print(type(ss2)) # <class 'bytes'>
# unicode ---> utf-8
print("------------- unicode ---> utf-8 -----------")
s1 = '中国'
b1 = s1.encode('utf-8') # 编码
print(b1)
print(type(b1)) # <class 'bytes'>
# utf-8 ---> unicode
print("------------- utf-8 ---> unicode -----------")
s2 = b1.decode('utf-8') # 解码
print(s2)
print(type(s2)) # <class 'str'>
# gbk
print("------------- gbk -----------")
s1 = '中央'
b1 = s1.encode('gbk') # 编码
print(b1)
# utf-8 ----> unicode
s2 = b1.decode('gbk') # 解码
print(s2)
# gbk ---> utf-8
print("-------------- gbk ---> utf-8 ----------")
b1 = b'\xd6\xd0\xb9\xfa' # 中国 这个字符串的的gbk编码
s1 = b1.decode('gbk') # gbk ---> Unicode
print(s1) # 中国
print(type(s1)) # <class 'str'>
b2 = s1.encode('utf-8') # Unicode ---> bytes
print(b2)
print(type(b2)) # <class 'bytes'>
基础数据类型转化
#!/usr/bin/env python3
# author:Alnk(李成果)
"""
bool <---> int
str <---> int
s1 = '100' 全部由数字组成的str ---> int
int(s1)
str(100)
str <---> bool 非空即True '' 空即False
"""
print("-------- bool <---> int ------------ ")
print(int(True)) # 1
print(int(False)) # 0
print(bool(1)) # True 非零为True
print(bool(-1)) # True
print(bool(0)) # False
print("-------- str <---> int ------------ ")
print(int("100")) # 100
# print(int("a")) # 会报错
print(str(100)) # 100
print("-------- str <---> bool ------------ ")
print(bool("a")) # True 非空为true
print(bool("")) # False
字符串str
#!/usr/bin/env python3
# author:Alnk(李成果)
# 字符串常用操作方法
# 对字符串进行的任何操作都会形成一个新字符串，与原字符串无关
# 索引
print("-------------- 字符串索引 --------------")
s1 = 'python中国'
s2 = s1[0]
print(s2, type(s2))
s3 = s1[2]
print(s3)
print(s1[-1])
# 切片：顾首不顾尾
print("-------------- 字符串切片 --------------")
s4 = s1[0:6]
print(s4)
s8 = s1[:6]
print(s8)
s5 = s1[2:6]
print(s5)
s6 = s1[:]
print(s6)
# 切片+步长 [起始索引: 结尾索引: 步长]
s7 = s1[:5:2]
print(s7)
# 反着取值（反向步长）
print(s1[-1:-4:-1])
print(s1[-3::1])
print(s1[-3::-1])
# upper lower
# upper 全大写
# lower 全小写
print("----------------- upper 和 lower ------------------")
s1 = 'aLNk'
s2 = s1.lower()
print(s2)
print(s1)
s3 = s1.upper()
print(s3)
# 例子
# username = input('请输入用户名>>>:')
# password = input('请输入密码>>>:')
# code = 'afREd'.upper()
# your_code = input('请输入验证码>>>:').upper()
# if code == your_code:
# if username == 'tom' and password == '123':
# print('登录成功')
# else:
# print('验证码错误')
# strip
# 默认(指定)去除字符串两边的换行符，制表符，空格。
# lstrip rstrip
print("----------------- strip ------------------")
s1 = ' \talnk\n'
print(s1)
print(s1.strip())
s2 = 'reaeareelexqw'
print(s2.strip('qwer')) # aeareelex
s3 = ' alnk '
print(s3.lstrip())
print(s3.rstrip())
# 例子
# username = input('请输入用户名').strip()
# password = input('请输入密码').strip()
# if username == 'tom' and password == '123':
# print('登录成功')
# find index
# find 通过元素找索引，找到第一个则返回，找不到返回-1
# index 通过元素找索引，找到第一个则返回，找不到则报错
print("---------------- find 和 index -----------------")
s1 = '深圳南山pythonon中国'
i = s1.find('w')
print(i) # -1
i = s1.find('中')
print(i) # 12
# i = s1.index('w') # 会报错
# print(i)
i = s1.index('p')
print(i) # 4
# startswith endswith
# startswith 判断以...为开始
# endswith 判断以...为结尾
print("---------------- startswith 和 endswith -----------------")
s1 = '中国ChinaChina'
print(s1.startswith("中")) # True
print(s1.startswith("C", 2, 7)) # True
print(s1.startswith("bb", 2, 5)) # False
print(s1.endswith("ba", 2, 5)) # False
print(s1.endswith('na')) # True
# split
# split 默认(可指定分隔符)以空格为分割，返回一个列表。
# str ----> list
print("---------------- split -----------------")
s1 = 'alnk tom 深圳 广东'
s11 = ':alnk:tom:深圳:广东'
s12 = 'alnk:tom:深圳:广东'
l1 = s1.split()
print(l1) # ['alnk', 'tom', '深圳', '广东']
l2 = s11.split(':')
print(l2) # ['', 'alnk', 'tom', '深圳', '广东']
# 指定分隔次数
l3 = s12.split(':', 1)
print(l3) # ['alnk', 'tom:深圳:广东']
# join
# join 可以操作任何数据类型（由多个对象组成即可），并不止字符串
print("---------------- join -----------------")
s1 = 'alnk'
s2 = '_'.join(s1)
print(s2)
s2 = '*'.join(s1)
print(s2)
# 列表拼接
# 前提条件：此列表必须全部是有字符串元素组成
l1 = ['alnk', 'tom', '深圳', '广东']
s2 = ' '.join(l1)
print(s2)
s3 = '*'.join(l1)
print(s3)
# replace
# replace 默认全部替换 也可以设置替换次数
print("---------------- replace -----------------")
s1 = 'python深圳 深圳是一个很美丽的城市，我爱深圳'
s2 = s1.replace('深圳', '北京')
print(s2)
s2 = s1.replace('深圳', '北京', 1)
print(s2)
# count
# count 计算某个元素出现的次数
print("---------------- count -----------------")
s1 = 'barryafdfdafdaaa'
i = s1.count('a')
print(i)
# is 系列
print("---------------- is 系列 -----------------")
name = 'alnk123'
print(name.isalnum()) # 字符串由字母或数字组成 True
print(name.isalpha()) # 字符串只由字母组成 False
print(name.isdigit()) # 字符串只由数字组成 False
# len 内置函数,统计字符串长度
print("---------------- len -----------------")
s1 = 'fjdsklfsjafldsfjskladfjsladfjldksa'
print(len(s1))
for循环
#!/usr/bin/env python3
# author:Alnk(李成果)
# for 循环
s1 = 'python中国'
count = 0
while count < len(s1):
print(s1[count])
count += 1
print("-------------- 分隔符 -------------------")
# for 变量 in iterable:
# pass
for i in s1:
print(i, type(i))
print("-------------- 分隔符 -------------------")
for i in s1:
print(i + 'nb')
列表
#!/usr/bin/env python3
# author:Alnk(李成果)
# 列表 list
# 容器类的数据类型：基础数据类型之一 list
# 列表可以存储大量的数据，列表是有序的
# 列表有索引，切片，切片（步长）
# 索引，切片
print("------------- 列表的索引和切片 --------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
print(l1[0], type(l1[0])) # 100 <class 'int'>
print(l1[-2]) # True
# 顾首不顾尾
print(l1[:3]) # [100, 'tom', True]
# 增删改查其他操作
print("------------- 列表增删改查 --------------------")
# 增
print("------------- 增 --------------------")
l1 = ['tom', 'jerry', '深圳', '广东', '南山']
# append 追加
l1.append("666")
print(l1) # ['tom', 'jerry', '深圳', '广东', '南山', '666']
# insert插入
l1.insert(1,'lilei')
print(l1) # ['tom', 'lilei', 'jerry', '深圳', '广东', '南山', '666']
# extend 迭代着追加，增加多个（拆解成最小的元素追加到列表最后）
l1.extend('abc')
print(l1) # ['tom', 'lilei', 'jerry', '深圳', '广东', '南山', '666', 'a', 'b', 'c']
l1.extend([1,2,3])
print(l1) # ['tom', 'lilei', 'jerry', '深圳', '广东', '南山', '666', 'a', 'b', 'c', 1, 2, 3]
# 删
print("------------- 删 --------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
# pop 按照索引删除 有返回值，如果不加索引，默认删除最后一个元素
ret = l1.pop(-1)
print(ret) # [1, 2, 3]
# remove 按照元素删除
l1.remove('tom')
print(l1) # [100, True]
# clear清空列表
l1.clear()
print(l1) # []
# del从内存中删除整个列表，或者按照索引删除单个元素，多个元素
l1 = [100, 'tom', True, [1, 2, 3]]
del l1[0] # 按照索引删除
del l1[:2] # 按照切片删除
del l1
# print(l1) # 会报错
# 改
print("------------- 改 --------------------")
# 按照索引改值
l1 = [100, 'tom', True, [1, 2, 3]]
l1[1] = 'sb'
print(l1) # [100, 'sb', True, [1, 2, 3]]
# 按照切片改值
l1[:3] = 'abcd'
print(l1) # ['a', 'b', 'c', 'd', [1, 2, 3]]
# 查：可以索引切片 for循环
print("------------- 查 ------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
for i in l1:
print(i)
# 其他操作方法
print("------------- 其他操作方法 ------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
print(len(l1)) # 元素个数 4
# count 次数
ret = l1.count('tom')
print(ret) # 1
# index 通过元素找索引，找不到报错
print("------------- index ------------------")
l1 = [100, 'tom', 'a', True, [1, 2, 3]]
ret = l1.index('a')
print(ret) # 2
# sort 排序
print("------------- sort ------------------")
l2 = [5, 6, 4, 0, 9, 1, 7, 8]
l2.sort() # 从小到大
print(l2) # [0, 1, 4, 5, 6, 7, 8, 9]
l2.sort(reverse=True) # 从大到小
print(l2) # [9, 8, 7, 6, 5, 4, 1, 0]
l2.reverse() # 翻转
print(l2)
# 列表的嵌套
print("---------------- 列表的嵌套 ----------------")
l1 = [1, 2, 'jerry', [1, 'tom', 3, ]]
# 1, 将l1中的'jerry'变成大写并放回原处
# 2，给小列表[1,'tom',3,]追加一个元素,'中国'
# 3，将列表中的'tom'通过字符串拼接的方式在列表中变成'tomsb'
# 1
l1[2] = l1[2].upper()
print(l1) # [1, 2, 'TAIBAI', [1, 'alex', 3]]
# 2
l1[3].append("中国")
print(l1) # [1, 2, 'JERRY', [1, 'tom', 3, '中国']]
# 3
# l1[3][1] = l1[3][1] + "sb"
# print(l1) # [1, 2, 'JERRY', [1, 'tomsb', 3, '中国']]
# 3
l1[3][1] = "tomsb"
print(l1)
# range 可以视为一个可控的数字范围的列表，多与for循环结合
print("------------------ range ----------------")
for i in range(1,10): # [1,2,3,4,...9]
print(i)
for i in range(20): # [0,1,2,3,4,...19]
print(i)
for i in range(1,10,2): # [1,2,3,4,...9]
print(i)
print(range(10))
# 倒着取值 顾首不顾尾
print("--------------------------------")
for i in range(10, 1, -1):
print(i)
# range 打印列表的索引
print("--------------------------------")
l1 = ['tom', 'jerry', '中国','广东', '深圳']
for index in range(len(l1)):
print(index)
print("--------------------------------")
for i in l1:
print(i)
元组
#!/usr/bin/env python3
# author:Alnk(李成果)
# 元组 tuple 基础数据类型之一
# 存储数据，重要的数据。
tu1 = (100, True, [1, 2, 3])
# 元组没有增删改，可以查询
for i in tu1:
print(i)
# 元组也有索引切片
print(tu1[0])
# 元组里面的列表是可以更改的
tu1 = (100, True, [1, 2, 3])
tu1[-1].append(666)
print(tu1)
# 补充
# tuple
# 元组中如果只有一个元素且没有逗号（那他不是元组），则与该元素数据类型相同。
tu1 = (1)
tu2 = ('tome')
print(tu1, type(tu1)) # 1 <class 'int'>
print(tu2, type(tu2)) # tome <class 'str'>
字典
#!/usr/bin/env python3
# author:Alnk(李成果)
"""
列表的不足
1 列表的数据量越大，查询速度越慢
2 列表存储的数据没有什么关联性
基础数据类型 字典dict
dic = {'name': 'tom'}
字典是以键值对的形式存储的
数据类型的划分：
可变的（不可哈希）数据类型：list dict set
不可变（可哈希）的数据类型：tuple str int bool
字典的键key：必须是不可变得数据类型：int str
字典的值：任意数据类型 变量，对象
字典可以存储大量的数据，而且字典的查询速度非常快
字典的key 唯一的不重复的
字典 3.5之前是无序的
字典在3.5之后是有序的 初始化时的顺序
构建数据类型：大量的关系型数据时，要想到字典
"""
# 增：
# 有则修改，无则增加
print("------------------- 增 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
dic['high'] = 175
print(dic) # {'name': 'tom', 'age': 18, 'sex': 'boy', 'high': 175}
dic['name'] = '日天'
print(dic) # {'name': '日天', 'age': 18, 'sex': 'boy', 'high': 175}
# 有则不变，无则增加
dic.setdefault('weight',200)
print(dic) # {'name': '日天', 'age': 18, 'sex': 'boy', 'high': 175, 'weight': 200}
dic.setdefault('age',73)
print(dic) # {'name': '日天', 'age': 18, 'sex': 'boy', 'high': 175, 'weight': 200}
# 删除
# pop 按照key删除键值对,有返回值
print("------------------- 删 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
ret = dic.pop('name')
print(ret) # tom
print(dic) # {'age': 18, 'sex': 'boy'}
# clear 清空字典
dic.clear()
print(dic) # {}
# del 删除整个字典或者某个键值对
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
del dic
# print(dic)
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
del dic['name']
# 改
print("------------------- 改 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
dic['name'] = '日天'
print(dic) # {'name': '日天', 'age': 18, 'sex': 'boy'}
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"tom","weight":75}
dic2.update(dic) # 将dic的键值对覆盖添加到dic2中，dic不变。
print(dic2) # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
print(dic) # {'name': 'jin', 'age': 18, 'sex': 'male'}
# 查
print("------------------- 查 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
print(dic['name']) # tom
# print(dic['name1']) # 报错
ret = dic.get('name')
print(ret) # tom
ret = dic.get('name1')
print(ret) # None
ret = dic.get('name1', '没有此键')
print(ret) # 没有此键
for i in dic:
print(i,dic[i])
# 其他方法：
# dic.keys() dic.values() dic.items()
print(dic.keys(),type(dic.keys())) # dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>
for key in dic.keys():
print(key,type(key))
print("------------------------- 1 -------------------")
for v in dic.values():
print(v)
print("------------------------ 2 --------------------")
print(list(dic.items())) # [('name', 'tom'), ('age', 18), ('sex', 'boy')]
# 分别赋值
print("-------------------- 分别赋值 -------------------------")
a, b = 1, 4
print(a,b) # 1 4
a, b = (1,4)
print(a, b, type(a)) # 1 4 <class 'int'>
a, b = [[1,2,3],'tom']
print(a,b) # [1, 2, 3] tom
# 嵌套
print("-------------------- 嵌套 -------------------------")
dic = {
'name_list': ['张三', '李四', 'TOM'],
1:{'name':'TOM', 'age': 18},
'TOM': {}
}
# 1，给列表追加一个值：'王五'
# dic['name_list'].append('王五')
# print(dic) # {'name_list': ['张三', '李四', 'TOM', '王五'], 1: {'name': 'TOM', 'age': 18}, 'TOM': {}}
# 2，将 列表中的TOM 变成小写
# print(dic['name_list'][-1].lower()) # tom
# dic['name_list'][-1] = dic['name_list'][-1].lower()
# print(dic) # {'name_list': ['张三', '李四', 'tom'], 1: {'name': 'TOM', 'age': 18}, 'TOM': {}}
# 3，给{'name':'TOM', 'age': 18} 增加一个键值对 sex: 男。
print(dic[1])
dic[1]['sex'] = '男'
print(dic) # {'name_list': ['张三', '李四', 'TOM'], 1: {'name': 'TOM', 'age': 18, 'sex': '男'}, 'TOM': {}}
基础数据类型练习
#!/usr/bin/env python3
# author:Alnk(李成果)
# int str bool list tuple dict
# 数据类型的转换。
# str ————> list split
# list ————> str join
# list tuple
# tuple ---> list
print(list((1, 2, 3, 'alex')))
# list ---> tuple
print(tuple([1, 2, 3, 'alex']))
# dict ---> list
dic = {"name": "jin", "age": 18, "sex": "male"}
print(list(dic))
# list
l1 = [11, 22, 33, 44, 55]
# 将列表中索引为奇数位的元素删除
# 正常思路（错误示范）元素会左移
# 对于列表来说，你在循环一个列表时，不要改变列表的大小，会影响你的最终结果
# for index in range(len(l1)):
# if index % 2 == 1:
# del l1[index]
# print(l1)
# 方法一：
del l1[1::2]
print(l1)
# 字典
# 将字典的键中含有k元素的所有键值对删除
dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'name': 'tom'}
# 错误示范
# for key in dic:
# if 'k' in key:
# dic.pop(key)
# print(dic)
# 满足条件的key添加到一个新列表中，循环列表删除相应的键值对。
l1 = []
for key in dic:
if 'k' in key:
l1.append(key)
print(l1)
for i in l1:
dic.pop(i)
print(dic)
练习题1
#!/usr/bin/env python3
# author:Alnk(李成果)
# 1、有变量name = "aleX leNb " 完成如下操作
name = "aleX leNb"
# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
# 2) 移除name变量左边的"al"并输出处理结果
print(name.lstrip('al'))
# 3) 移除name变量右面的"Nb",并输出处理结果
print(name.rstrip('Nb'))
# 4) 移除name变量开头的a"与最后的"b",并输出处理结果
print(name.strip('ab'))
# 5) 判断 name 变量是否以 "al" 开头,并输出结果
print(name.startswith('al'))
# 6) 判断name变量是否以"Nb"结尾,并输出结果
print(name.endswith('Nb'))
# 7) 将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果
print(name.replace('l', 'p'))
# 8) 将name变量对应的值中的第一个"l"替换成"p",并输出结果
print(name.replace('l', 'p', 1))
# 9) 将 name 变量对应的值根据 所有的"l" 分割,并输出结果。
print(name.split('l'))
# 10) 将name变量对应的值根据第一个"l"分割,并输出结果。
print(name.split('l', 1))
# 11) 将 name 变量对应的值变大写,并输出结果
print(name.upper())
# 12) 将 name 变量对应的值变小写,并输出结果
print(name.lower())
# 13) 将name变量对应的值首字母"a"大写,并输出结果
print(name.capitalize())
# 14) 判断name变量对应的值字母"l"出现几次，并输出结果
print(name.count('l'))
# 15) 如果判断name变量对应的值前四位"l"出现几次,并输出结果
print(name.count('l', 0, 5))
# 16) 从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
print(name.index('N'))
# 17) 从name变量对应的值中找到"N"对应的索引(如果找不到则返回‐1)输出结果
print(name.find('N'))
# 18) 从name变量对应的值中找到"X le"对应的索引,并输出结果
print(name.find("X le"))
# 19) 请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 20) 请输出 name 变量对应的值的前 3 个字符?
print(name[:3])
# 21) 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
# 22) 请输出 name 变量对应的值中所有 "e" 所在索引位置?
l1 = []
for i in range(len(name)):
if name[i] == 'e':
l1.append(i)
print(l1)
print("-" * 20)
# 2、有字符串s = "123a4b5c"
s = "123a4b5c"
# 1)通过对s切片形成新的字符串s1,s1 = "123"
s1 = s[:3]
print(s1)
# 2)通过对s切片形成新的字符串s2,s2 = "a4b"
s2 = s[3:6]
print(s2)
# 3)通过对s切片形成新的字符串s3,s3 = "1345"
s3 = s[::2]
print(s3)
# 4)通过对s切片形成字符串s4,s4 = "2ab"
s4 = s[1:-2:2]
print(s4)
# 5)通过对s切片形成字符串s5,s5 = "c"
s5 = s[-1]
print(s5)
# 6)通过对s切片形成字符串s6,s6 = "ba2"
s6 = s[-3::-2]
print(s6)
print("-" * 20)
# 3、使用while或for循环分别打印字符串s="asdfer"中每个元素。
s = "asdfer"
for i in s:
print(i)
print("-" * 20)
count = 0
while count < len(s):
print(s[count])
count += 1
print("-" * 20)
# 4、使用for循环对s="asdfer"进行循环，但是每次打印的内容都是"asdfer"
s = "asdfer"
for i in s:
print(s)
print("-" * 20)
# 5、使用for循环对s="abcdefg"进行循环，每次打印的内容是每个字符加上sb， 例如：asb, bsb，csb,...gsb
s = "abcdefg"
for i in s:
print(i + 'sb')
print("-" * 20)
# 6、使用for循环对s="321"进行循环，打印的内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"，"出发！"
s= "321"
for i in s:
print("倒计时%s秒" % (i))
print("出发！")
print("-" * 20)
# 7、实现一个整数加法计算器(两个数相加)：
# 如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9，然后进行分割再进行计算。
content = input("请输入内容：")
content = content.replace(' ','')
content_list = content.split('+')
sum = int(content_list[0]) + int(content_list[1])
print(sum)
print("-" * 20)
# 8、升级题：实现一个整数加法计算器（多个数相加）：
# 如：content = input("请输入内容:") 用户输入：5+9+6 +12+ 13，然后进行分割再进行计算
content = input("请输入内容：")
content = content.replace(' ', '')
content_list = content.split('+')
sum = 0
for i in content_list:
sum = sum + int(i)
print(sum)
print("-" * 20)
# 9、计算用户输入的内容中有几个整数（以个位数为单位）
# 如：content = input("请输入内容：") # 如fhdal234slfh98769fjdla
content = input("请输入内容：")
sum = 0
for i in content:
if i.isdigit():
sum += 1
print(sum)
# 10、写代码，完成下列需
# 用户可持续输入（用while循环），用户使用的情况：
# 输入A，则显示走大路回家，然后在让用户进一步选择：
# 是选择公交车，还是步行？
# 选择公交车，显示10分钟到家，并退出整个程序。
# 选择步行，显示20分钟到家，并退出整个程序。
# 输入B，则显示走小路回家，并退出整个程序。
# 输入C，则显示绕道回家，然后在让用户进一步选择：
# 是选择游戏厅玩会，还是网吧？
# 选择游戏厅，则显示 ‘一个半小时到家，爸爸在家，拿棍等你。’并让其重新输入A，B,C选项。
# 选择网吧，则显示‘两个小时到家，妈妈已做好了战斗准备。’并让其重新输入A，B,C选项。
flag = True
while flag:
user_choice1 = input("请输入A or B or C:")
if user_choice1.upper() == "A":
print("走大路回家")
while flag:
user_choice2 = input("\t公交车回家输入1，步行回家输入2:")
if user_choice2 == "1":
print("10分钟到家")
flag = False
elif user_choice2 == "2":
print("20分钟到家")
flag = False
else:
print("输入有误哦，请重新输入")
continue
elif user_choice1.upper() == "B":
print("走小路回家")
flag = False
elif user_choice1.upper() == "C":
print("绕道回家")
while flag:
user_choice3 = input("\t游戏厅输入1，网吧输入2:")
if user_choice3 == "1":
print("一个半小时到家，爸爸在家，拿棍等你\n")
break
elif user_choice3 == "2":
print("两个小时到家，妈妈已做好了战斗准备\n")
break
else:
print("输入有误哦，请重新输入")
continue
else:
print("只能输入A或B或C哦")
print("-" * 20)
# 11、写代码：计算 1 - 2 + 3 ... + 99 中除了88以外所有数的总和？
# 方法1
odd_sum = 0
even_sum = 0
count = 1
while count < 100:
if count % 2 == 1:
odd_sum = odd_sum + count
elif count % 2 == 0:
if count == 88:
pass
else:
even_sum = even_sum + count
count = count + 1
print("总和为:",odd_sum - even_sum)
# 方法2
sum = 0
count = 0
while count < 99:
count += 1
if count == 88:
count +=1
if count % 2 == 0:
sum = sum - count
else:
sum = sum + count
print(sum)
print("-" * 20)
# 16、制作趣味模板程序需求：等待用户输入名字、地点、爱好、根据用户的名字和爱好进行任意实现
# 如：敬爱可亲的xxx，最喜欢在xxx地进行xxx
name = input("姓名:")
addr = input("地点:")
hobby = input("爱好:")
msg = '敬爱可亲的[%s]，最喜欢在[%s]地进行[%s]' % (name,addr,hobby)
print(msg)
print("-" * 20)
# 17、等待用户输入内容，检测用户输入内容中是否包含敏感字符？如果存在敏感字符提示"存在敏感字符请重新输入"
# 并允许用户重新输入并打印。敏感字符："粉嫩"、"铁锤"
flag = True
while flag:
user_str = input("请输入内容:")
if "粉嫩" in user_str.replace(' ','') or "铁锤" in user_str.replace(' ',''):
print("存在敏感字符请重新输入")
continue
else:
print(user_str)
flag = False
print("-" * 20)
# 18、写代码，有如下列表，按照要求实现每一个功能
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
# 1)计算列表的长度并输出
print(len(li))
# 2)列表中追加元素"seven",并输出添加后的列表
li.append('seven')
print(li)
# 3)请在列表的第1个位置插入元素"Tony",并输出添加后的列表
li.insert(1,'Tony')
print(li)
# 4)请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
li[1] = 'Kelly'
print(li)
# 5)请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
l2 = [1,"a",3,4,"heart"]
li.extend(l2)
print(li)
# 6)请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
s = "qwert"
li.extend(s)
print(li)
# 7)请删除列表中的元素"barry",并输出添加后的列表
li.remove('barry')
print(li)
# 8)请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
li.pop(1)
print(li)
# 9)请删除列表中的第2至4个元素，并输出删除元素后的列表
del li[1:4]
print(li)
# 10)请将列表所有得元素反转，并输出反转后的列表
li.reverse()
print(li)
# 11)请计算出"alex"元素在列表li中出现的次数，并输出该次数。
print(li.count('alex'))
print("-" * 30)
# 19、写代码，有如下列表，利用切片实现每一个功能
li = [1, 3, 2, "a", 4, "b", 5,"c"]
# 1)通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
l1 = li[:3]
print(l1)
# 2)通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
l2 = li[3:6]
print(l2)
# 3)通过对li列表的切片形成新的列表l3,l3 = [1,2,4,5]
l3 = li[::2]
print(l3)
# 4)通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
l4 = li[1:-1:2]
print(l4)
# 5)通过对li列表的切片形成新的列表l5,l5 = ["c"]
l5 = li[-1]
print(l5)
# 6)通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
l6 = li[-3::-2]
print(l6)
print("-" * 30)
# 20、写代码，有如下列表，按照要求实现每一个功能。
# lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 1)将列表lis中的"tt"变成大写（用两种方式）
# 方法1
lis[3][2][1][0] = lis[3][2][1][0].upper()
print(lis)
# 方法2
lis[3][2][1][0] = 'TT'
print(lis)
# 2)将列表中的数字3变成字符串"100"（用两种方式）
# 方法1
lis[1] = '100'
lis[3][2][1][1] = '100'
print(lis)
# 方法2 脑洞开大一点就行了
lis[1] = str(lis[1] + 97)
print(lis)
# 3)将列表中的字符串"1"变成数字101（用两种方式）
# 方法1
lis[3][2][1][2] = '101'
print(lis)
print("-" * 30)
# 21、请用代码实现
# 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
li = ["alex", "eric", "rain"]
s1 = '_'.join(li)
print(s1)
print("-" * 30)
# 22、利用for循环和range打印出下面列表的索引。
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
for index in range(len(li)):
print(index)
print("-" * 30)
# 23、利用for循环和range找出100以内所有的偶数并将这些偶数插入到一个新列表中。
l1 = []
for i in range(101):
if i % 2 == 0:
l1.append(i)
print(l1)
print("-" * 30)
# 24、利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中。
l1 = []
for i in range(51):
if i % 3 ==0:
l1.append(i)
print(l1)
print("-" * 30)
# 25、利用for循环和range从100~1，倒序打印。
for i in range(100,0,-1):
print(i)
print("-" * 30)
# 26、利用for循环和range从100~10，倒序将所有的偶数添加到一个新列表中，
# 然后对列表的元素进行筛选，将能被4整除的数留下来
l1 = []
for i in range(100,9,-1):
if i % 2 == 0:
l1.append(i)
l2 = []
for i in l1:
if i % 4 ==0:
l2.append(i)
print(l2)
print("-" * 30)
# 26、利用for循环和range，将1-30的数字依次添加到一个列表中，并循环这个列表，将能被3整除的数改成*。
l1 = []
for i in range(1,31):
l1.append(i)
print(l1)
l2 = []
for i in l1:
if i % 3 == 0:
l2.append('*')
else:
l2.append(i)
print(l2)
print("-" * 30)
# 27、查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头，并以"c"结尾的所有元素，
# 并添加到一个新列表中,最后循环打印这个新列表。
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
new_li = []
for i in li:
if i.strip().lower().startswith('a') and i.strip().endswith('c'):
new_li.append(i.strip())
print('新列表:',new_li)
print("-" * 30)
# 28、开发敏感词语过滤程序，提示用户输入评论内容，如果用户输入的内容中包含特殊的字符：
# 敏感词列表 li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
# 则将用户输入的内容中的敏感词汇替换成等长度的*（苍老师就替换***），并添加到一个列表中；
# 如果用户输入的内容没有敏感词汇，则直接添加到上述的列表中
li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
new_li = []
user_comm = input("请输入评论内容:")
for i in li:
while i in user_comm:
user_comm = user_comm.replace(i,(len(i) * "*"))
new_li.append(user_comm)
print(new_li)
print("-" * 30)
# 29、有如下变量（tu是个元祖），请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# a. 讲述元祖的特性
# 元组是基础的数据类型之一，它不可以增，删，改，但是可以查询，也可以索引切片
# b. 请问tu变量中的第一个元素 "alex" 是否可被修改？
# 不能被修改
# c. 请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素"Seven"
# k2 对应的值是一个列表，可以被修改。
tu[1][2]['k2'].append('Seven')
print(tu)
# d. 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素"Seven"
# k3 对应的值是一个元组，不能修改
print("-" * 30)
# 30、字典dic
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# a. 请循环输出所有的key
for k in dic:
print(k)
# b. 请循环输出所有的value
for v in dic.values():
print(v)
# c. 请循环输出所有的key和value
for k,v in dic.items():
print(k,v)
# d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4'] = 'v4'
print(dic)
# e. 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
dic['k1'] = 'alex'
print(dic)
# f. 请在k3对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
# g. 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,18)
print(dic)
print("-" * 30)
# 31、如下
av_catalog = {
"欧美":{
"www.youporn.com": ["很多免费的,世界最大的","质量一般"],
"www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
"x‐art.com":["质量很高,真的很高","全部收费,屌丝请绕过"]
},
"日韩":{
"tokyo‐hot":["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]
},
"大陆":{
"1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
},
}
# a,给此 ["很多免费的,世界最大的","质量一般"]列表第二个位置插入一个 元素：'量很大'。
av_catalog['欧美']["www.youporn.com"].insert(1,'量很大')
print(av_catalog)
# b,将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。
av_catalog['欧美']["x‐art.com"].remove("全部收费,屌丝请绕过")
print(av_catalog)
# c,将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。
av_catalog['欧美']["x‐art.com"].remove("全部收费,屌丝请绕过")
print(av_catalog)
# d,将此["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]列表的 "verygood"全部变成大写。
av_catalog["日韩"]["tokyo‐hot"][1] = av_catalog["日韩"]["tokyo‐hot"][1].upper()
print(av_catalog)
# e,给 '大陆' 对应的字典添加一个键值对 '1048' :['一天就封了']
av_catalog["大陆"]['1048'] = ['一天就封了']
print(av_catalog)
# f,删除此"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"]键值对。
del av_catalog["欧美"]["letmedothistoyou.com"]
print(av_catalog)
# g,给此["全部免费,真好,好人一生平安","服务器在国外,慢"]列表的第一个元素，加上一句话：'可以爬下来'
av_catalog["大陆"]["1024"].insert(0,'可以爬下来')
print(av_catalog)
print("-" * 30)
# 32、有字符串"k:1|k1:2|k2:3|k3:4" 处理成字典 {'k':1,'k1':2....}
s = "k:1|k1:2|k2:3|k3:4"
l1 = s.split('|')
dic = {}
for i in l1:
k,v = i.split(':')
dic[k] = v
print(dic)
print("-" * 30)
# 33、元素分类
# 有如下值li= [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于66 的值保存至第二个key的值中。
# 即： {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表}
li= [11,22,33,44,55,66,77,88,99,90]
dic = {'k1':[],'k2':[]}
for i in li:
if i > 66:
dic['k1'].append(i)
elif i < 66:
dic['k2'].append(i)
print(dic)
练习题2
#!/usr/bin/env python3
# author:Alnk(李成果)
"""
需求:
1. 用户先给自己的账户充钱：比如先充3000元
2. 页面显示 序号 + 商品名称 + 商品价格，如：
1 电脑 1999
2 鼠标 10
…
n 购物车结算
3. 用户输入选择的商品序号，然后打印商品名称及商品价格,并将此商品，添加到购物车，用户还可继续添加商品
4. 如果用户输入的商品序号有误，则提示输入有误，并重新输入
5. 用户输入n为购物车结算，依次显示用户购物车里面的商品，数量及单价，若充值的钱数不足，则让用户删除某商品，直至可以购买，
若充值的钱数充足，则可以直接购买
6. 用户输入Q或者q退出程序
7. 退出程序之后，依次显示用户购买的商品，数量，单价，以及此次共消费多少钱，账户余额多少
"""
# 商品列表
goods_dic = {
"1":{"name":"电脑","price":1999,},
"2":{"name":"鼠标","price":10,},
"3":{"name":"键盘","price":60,},
"4":{"name":"手机","price":4000,},
"5":{"name":"ipad","price":2999,},
"n":{"name":"购物车结算","price":'',},
}
# 用户购物车
user_shopping_cart = {}
# 标志位
flag = True
# 充值
while flag:
print('------------ 您好，欢迎来到购物商城 ----------------')
user_balance = input("请先给账号充值(退出Q/q):")
if user_balance.lower() == "q":
print("退出，欢迎下次光临！")
flag = False
elif user_balance.isdigit():
user_balance = int(user_balance)
print("账号充值成功！余额为[%s]元\n" % (user_balance))
break
else:
print("输入有误，请重新输入。")
# 主程序
while flag:
print("下列是您可以选购的商品(退出Q/q):")
for key in goods_dic:
print('\t',key,goods_dic[key]['name'],goods_dic[key]['price'])
user_choice = input("请输入你想购买的商品序号:")
if user_choice.lower() == "q":
print("退出购物商城")
flag = False
# 结算
elif user_choice == "n":
while flag:
# 显示购车里的商品
print("\n您的购车里商品如下:")
for k in user_shopping_cart:
print("\t商品[%s] 数量[%s] 价格[%s]" % (k, user_shopping_cart[k]['number'] ,user_shopping_cart[k]['price']) )
# 购物车所有商品总价
shopp_cart_total = 0
print("\n正在结算，请稍候...")
# 计算商品总价格
for k in user_shopping_cart:
shopp_cart_total = shopp_cart_total + user_shopping_cart[k]['number'] * user_shopping_cart[k]['price']
# 判断余额是否能够支付
if user_balance >= shopp_cart_total:
print("您本次总共需要支付[%s]元，余额为[%s]元" % (shopp_cart_total,user_balance))
print("\n您本次购买的商品详单如下：")
for k in user_shopping_cart:
print('\t商品[%s] 数量[%s] 价格[%s]' % (k, user_shopping_cart[k]['number'], user_shopping_cart[k]['price']) )
print("\n本次总共消费[%s]元，账户余额为[%s]元" % (shopp_cart_total,user_balance-shopp_cart_total) )
print("\n购买成功!")
flag = False
else:
print("本次总共需要支付[%s]元 你的余额为[%s]元" % (shopp_cart_total,user_balance))
print("余额不足，请先删除购物车里的一些商品再去结算哟\n")
while flag:
print("\n购物车的商品列表如下:")
for k in user_shopping_cart:
print('\t商品[%s] 数量[%s] 价格[%s]' % (k,user_shopping_cart[k]['number'],user_shopping_cart[k]['price']) )
user_choice2 = input("请输入你想删除的商品名称:")
if user_shopping_cart.get(user_choice2):
if user_shopping_cart[user_choice2]['number'] == 1:
del user_shopping_cart[user_choice2]
print('商品[%s]已从购物车删除' % (user_choice2))
elif user_shopping_cart[user_choice2]['number'] > 1:
user_shopping_cart[user_choice2]['number'] -= 1
print("商品[%s]数量减少1件" % (user_choice2))
break
else:
print("\n输入的商品名称有误，请重新输入")
# 添加商品到用户购物车
elif goods_dic.get(user_choice):
if user_shopping_cart.get(goods_dic[user_choice]['name']):
user_shopping_cart[goods_dic[user_choice]['name']]['number'] += 1
else:
user_shopping_cart[goods_dic[user_choice]['name']] = {"number":1,"price":goods_dic[user_choice]['price']}
print("\n商品[%s] 价格[%s] " % (goods_dic[user_choice]['name'], goods_dic[user_choice]['price']))
print('添加到购物车成功！\n')
else:
print("输入有误，请重新输入哦\n")
转载请注明出处哟~
https://www.cnblogs.com/lichengguo
