Python---字符串-列表-元组-集合-字典

最新推荐文章于 2024-06-19 14:52:02 发布

橘子没有壳

最新推荐文章于 2024-06-19 14:52:02 发布

阅读量337

点赞数 1

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/qq_37382077/article/details/94902549

版权

python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

字符串

"""
#字符串的定义
"""
a = 'westos'
b = "what's"
c = """
    用户管理管理系统
    1.添加用户
    2.删除用户
    3.显示用户
    .....

"""
print(c)

在这里插入图片描述

字符串的特性

s = 'hello'
# 索引：0 1 2 3 4(索引是从0开始)
print(s[0])
print(s[4])
print(s[-1]) #拿出最后一个字符
# 切片 s[start:stop:step] 从start开始到end -1结束
# 步长为step
print(s[0:3])
print(s[0:4:2])
print(s[:]) #显示所有的字符
print(s[:3]) #显示前3个字符
print(s[::-1]) #字符串的翻转
print(s[1:]) #除了第一个字符之外的其他全部字符
#重复
print(s * 10)
# 连接
print('hello ' + 'python')
# 成员操作符
print('he' in s)
print('aa' in s)
print('he' not in s)
#for循环遍历
for i in s:
    print(i)

在这里插入图片描述

字符串的常用方法

>>> 'Hello'.istitle()
True
>>> 'hello'.istitle()
False
>>> 'hello'.isupper()
False
>>> 'Hello'.isupper()
False
>>> 'HELLO'.isupper()
True
>>> 'hello'.islower()
True
>>> 'HELLO'.islower()
False
>>> 'HELLO'.lower()
'hello'
>>> 'hello'.upper()
'HELLO'
>>> 'hello'.title()
'Hello'

注意：去除左右两边的空格，空格为广义的空格包括：\t \n

>>> s = '       hello          '
>>> s
'       hello          '
>>> s.lstrip()
'hello          '
>>> s.rstrip()
'       hello'
>>> s.strip()
'hello'
>>> s = '\t\thello    \n\n'
>>> s
'\t\thello    \n\n'
>>> s.strip()
'hello'
>>> s.rstrip()
'\t\thello'
>>> s.lstrip()
'hello    \n\n'
>>> s = 'helloh'
>>> s.strip('h')
'ello'
>>> s.strip('he')
'llo'
>>> s.lstrip('he')
'lloh'

字符串的判断

  # 只要有一个元素不满足条件，就返回False
  print('313fsdfsd'.isdigit())
  print('ewqewq42423'.isalpha())
  print('23213fasfsa'.isalnum())

在这里插入图片描述

filename = 'hello.log'
if filename.endswith('.log'):
    print(filename)
else:
    print('error.file')

url = 'https://172.25.254.250/index.html'
if url.startswith('http://'):
    print('爬取网页')
else:
    print('不能爬取')

在这里插入图片描述
字符串的对齐

print('学生管理系统'.center(30))
print('学生管理系统'.center(30,'*'))
print('学生管理系统'.center(30,'&'))
print('学生管理系统'.ljust(30,'*'))
print('学生管理系统'.rjust(30,'*'))

在这里插入图片描述
字符串的查找和替换

s = 'hello world hello'

# find找到子字符串，并返回最小的索引
print(s.find('hello'))
print(s.find('world'))
print(s.rfind('hello'))

# 替换字符串中的hello为westos
print(s.replace('hello','westos'))

在这里插入图片描述
字符串的统计

print('hello'.count('l'))
print('hello'.count('ll'))

print(len('westosssss'))

在这里插入图片描述
字符串的分离和连接

s = '172.25.254.250'
s1 = s.split('.')
print(s1)
print(s1[::-1])

date = '2019-05-24'
date1 = date.split('-')
print(date1)

# 连接 通过指定的连接符，连接每个字符串
print(''.join(date1))
print('/'.join(date1))
print('~~'.join('hello'))

在这里插入图片描述

测试

“”"
题目要求:
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）
读都是一样
的整数。

示例:
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。从右向左读, 为 121- 。
因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数
“”"

num = input('Num:')
print(num == num[::-1])

“”"
变量名定义是否合法：
1.变量名可以由字母数字下划线组成
2.变量名只能以字母和或者下划线开头
s = ‘321csv_’ s[0] s[1:]
s = ‘asfasf%%’
‘_’
exit
“”"

# while True:
#     s = input('变量名：')
#     if s == 'exit':
#         print('exit')
#         break
#     if s[0].isalpha() or s[0] == '_':
#         for i in s[1:]:
#            if not(i.isalnum() or i == '_'):
#                print('%s变量名不合法' %(s))
#                break
#
#         else:
#             print('%s变量名合法' %(s))
#
#     else:
#         print('%s变量名不合法' %(s))

“”"
小米笔试编程题目
- 题目描述：
> 给定一个句子（只包含字母和空格），将句子中的单词位置反转，
单词用空格分割, 单词之间只有一个空格，前>后没有空格。
比如：（1） “hello xiao mi”-> “mi xiao hello”
- 输入描述:
> 输入数据有多组，每组占一行，包含一个句子(句子长度小于1000个字符)
- 输出描述:
> 对于每个测试示例，要求输出句子中单词反转后形成的句子
- 示例1:
```
- 输入
hello xiao mi
- 输出
mi xiao hello
“”"

    print(' '.join(input().split()[::-1]))

在这里插入图片描述

列表

"""
数组：存储同一种数据类型的集合 scores = [12,23,45]
列表(打了激素的数组):可以存储任意数据类型
"""
list = [1,1.2,True,'westos']
print(list,type(list))

# 列表里面也可以嵌套列表
list2 = [1,2,3,4,[1,1.2,True,'westos']]
print(list2,type(list2))

在这里插入图片描述

列表的特性

service = ['http','ftp','ssh']

# 索引
# 正向索引
print(service[0])
# 反向索引
print(service[-1])


# 切片
print(service[::-1])
print(service[1:])
print(service[:-1])


# 重复
print(service * 3)

# 连接
service1 = ['mysql','firewalld']
print(service + service1)

# 成员操作符
print('firewalld' in service)
print('ftp' in service)
print('mysql' not in service)

在这里插入图片描述

列表的常用方法

列表元素的增加

service = ['http','ftp','ssh']

# append():追加一个元素到列表
service.append('firewalld')
print(service)

# extend():拉伸 追加多个元素到列表中
service.extend(['mysql','nfs'])
print(service)

# insert() 在指定索引处插入元素
service.insert(1,'https')
print(service)

在这里插入图片描述
列表元素的删除

# >>> service = ['ftp','http','ftp','ssh']
# >>> service.pop()
# 'ssh'
# >>> service
# ['ftp', 'http', 'ftp']
# >>> a = service.pop()
# >>> a
# 'ftp'
# >>> service
# ['ftp', 'http']
# >>> service.pop(0)
# 'ftp'
# >>> service
# ['http']
# >>> service.pop()
# 'http'
# >>> service
# []
# >>> service.pop()
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# IndexError: pop from empty list

"""
# remove:删除列表元素
service = ['http','ftp','ssh']
# a = service.remove('ftp')
# print(a)
# print(service)

# 从内存中删除一个数据
del service[1]
print(service)

列表元素的查看

service = ['ftp','http','http','ssh','ftp','ssh','ftp','ssh']

# 查看元素在列表中出现的次数
print(service.count('ftp'))

# 查看指定元素的索引值(可以指定索引范围)
print(service.index('ssh'))
print(service.index('ssh',4,7))

列表元素的排序

service = ['http','ftp','ftp','ssh']
# 默认是按照Ascii码进行排序的
service.sort(reverse=True)
print(service)

phones = ['Tom','alice','borry','Borry']
phones.sort(key=str.upper)
print(phones)

在这里插入图片描述
列表元素的修改

service=['ftp','http','ssh','mysql']

#通过索引值，重新赋值
service[1]='mariadb'
print(service)

print(service[:-1])
print(service[:-1])
print(service[:3])

#通过切片赋值
service[:2]=['samba','nfs','iscsi']
print(service)

在这里插入图片描述

元组

"""
列表：打了激素的数组
元组：带了紧箍咒的列表
     不可变数据类型，没有增删改
     可以存储任意数据类型
"""
# 定义一个元组
t = (1, 2.4, True, 'redhat')
print(t, type(t))
#t[1]=2不可以修改元组元素
#print(t[1])

在这里插入图片描述

ti = ([[1], 'westos', {'gg': 23}])
ti[0].append(3)
print (ti, type(ti))

# 如果元组里面包含可变数据类型，可以间接的修改元组内容
t2 = ([1, 2, 3], 4)
print(t2, type(t2))
t2[0].append(5)
print (t2)

t3 = ()
print(t3, type(t3))
t4 = tuple([])
print(t4, type(t4))
t5 = list(t4)
print(t5, type(t5))

# 元组如果只有一个元素，元素后面一定要加逗号，否则数据类型不确定
t6 = (2)
t7 = (2,)
print(t6, type(t6))
print (t7, type(t7))

在这里插入图片描述

元组的特性

t=(10,1.3,True,'westos')
#索引
print(t[0])
#切片
print (t[:2])
print (t[::-1])
#连接
print(t+(1,3,6))
# 不同的数据类型之间不能连接
#print(t + [1,2,3])
# print(t + 'westos')
#重复
print (t*3)
#for循环
for i in t:
    print(i)
#成员操作符
print (1 in t)
print (True not in t)

在这里插入图片描述

元组的常用方法

t=(10,1.2,True,'westos','westos')
#统计元组中某元素出现的次数
print (t.count('westos'))
#获取元组中元素下标
print(t.index(1.2))

在这里插入图片描述

元组的应用场景

a = 1
b = 2
a, b = b, a #a,b=(2,1) a=(2,1)[0] b=(2,1)[1]
print(a,b)

# 打印变量
name = 'westos'
age = 11
t = (name,age)
print('name:%s,age:%d' %(name,age))
print('name:%s,age:%d' %t)

# 元组的赋值：有多少个元素，就用多少个变量接收
t = ('westos',10,100)
name,age,score =t
print(name,age,score)

在这里插入图片描述

集合

# 集合里面的元素不可重复的
s = {1,2,3,4,1,2,3,4}
print(s,type(s))
# 定义一个空集合
s2 = {} #默认情况下是dict
print(s2,type(s2))

s3 = set([])
print(s3,type(s3))

# 列表去重
li = [1,2,3,1,2,3,4,5,6,4,5,6]
print(list(set(li)))

在这里插入图片描述

集合的特性

"""
集合支持的特性只有：成员操作符
"""
s = {1, 2, 3}
print(1 in s)
print(1 not in s)

for i in s:
    print(i)
print('')

在这里插入图片描述

集合的常用方法

# 集合是一个可变的数据类型
# 添加顺序和在集合中存储的顺序不同
s = {6,7,8,9,1,2,3}
print(s)

# 添加
s.add(10)
s.add(0)
print(s)

# 增加多个元素
s.update({3,4,5,6,7,8})
print(s)

# 删除
s.pop()
s.pop()
print(s)
# 删除指定元素 元素必须要存在
s.remove(8)
print(s)

# 交集 并集 差集
s1 = {1,2,3}
s2 = {2,3,4}
# 并集
print('并集：',s1.union(s2))
print('并集：',s1 | s2)
# 交集
print('交集：',s1.intersection(s2))
print('交集：',s1 & s2)
#  差集
# s1和s2的差集：s1中有哪些元素s2中没有
print('差集：',s1.difference(s2))
print('差集：',s1-s2)
# s2和s1的差集
print('差集：',s2.difference(s1))
print('差集：',s2-s1)
# 对等差分:并集 - 交集
print('对等差分：',s1.symmetric_difference(s2))
print('对等差分：',s1^s2)
s3 = {'redhat','westos'}
s4 = {'redhat','westos','linux'}
# s3是否s4的子集
print(s3.issubset(s4))
# s3是否s4的超集
print(s3.issuperset(s4))
# 两个集合是不是不相交
print(s3.isdisjoint(s4))

在这里插入图片描述

测试

“”"
华为机测题:
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性
他先用计算机生成了N个1～1000之间的随机整数(N<=1000),
N是用户输入的，对于其中重复的数字，只保留一个，
把其余相同的数字去掉，
不同的数对应着不同的学生的学号，
然后再把这些数从小到大排序，
按照排好的顺序去找同学做调查，
请你协助明明完成“去重”与排序工作
sorted()
“”"

import random

s = set([])
for i in range(int(input('N:'))):
    s.add(random.randint(1,1000)) #利用集合中的元素不可重复的特点 去重
print(sorted(s))

字典

s = {}
print(s,type(s))

# 字典：key-value 键值对
s = {
    'linux':[100,99,88],
    'python':[190,56,78]
}
print(s,type(s))

# 工厂函数
d = dict()
print(d,type(d))

d = dict(a=1,b=2)
print(d,type(d))

# 字典的嵌套
student = {
    '123':{
        'name':'tom',
        'age':18,
        'score':99
    },
    '456':{
        'name':'lily',
        'age':19,
        'score':100
    }
}

print(student['123']['name'])

在这里插入图片描述

字典的特性

d = {
    '1':'a',
    '2':'b'
}

print(d['1'])
# 字典不支持切片的

# 成员操作符(针对key)
print('1' in d)
print('1' not in d)

# for循环 针对key
for key in d:
    print(key)
# 遍历字典
for key in d:
    print(key,d[key])
# 遍历字典
for key,v in d.items():
    print(key,v)

在这里插入图片描述

字典元素的增加

service = {
    'http':80,
    'ftp':23
}

#增加一个元素
# 如果key值存在，则更新对应的value值
# 如果key值不存在，则添加对应的key-value值
service['https'] = 443
print(service)
service['ftp'] = 21
print(service)
# 增加多个key值
service_backup = {
    'tomcat':8080,
    'mysql':3306
}

service.update(service_backup)
print(service)
service.update(flask=9000,dns=53)
print(service)

# 如果key值存在：不做修改
# 如果key值不存在：则添加对应的key-value
service.setdefault('http',9090)
print(service)
service.setdefault('oracle',44575)
print(service)

在这里插入图片描述

字典元素的删除

service={
    'http':80,
    'ftp':21,
    'ssh':22
}
#del service['http']
print (service)

"""
pop删除指定key对应的value值
如果key存在，删除，并且返回删除key对应的value(可以用变量取接收)
如果不存在，直接报错
"""
# item = service.pop('https')
# print(item)
# print(service)
# popitem删除第一个key-value值
item = service.popitem()
print(item)
print(service)

# 清空字典内容
service.clear()
print(service)

在这里插入图片描述

字典元素的查看

service = {
    'http':80,
    'ftp':23,
    'ssh':22
}
# 查看字典的key值
print(service.keys())
# 查看字典的value值
print(service.values())
# 查看字典的key-value值
print(service.items())
"""
key不存在，默认返回None
key存在，default就返回defalut的值 没有就返回None
"""
print(service.get('https','443'))
print(service.get('https'))

在这里插入图片描述

测试

“”"
# 数字重复统计:
1). 随机生成1000个整数;
2). 数字的范围[20, 100],
3). 升序输出所有不同的数字及其每个数字重复的次数;
“”"

   import random
    all_num = []

for item in range(1000):
    all_num.append(random.randint(20,100))

# 对生成好的1000个数进行排序，然后加到子字典里
sorted_num = sorted(all_num)
num_dict ={}

for num in sorted_num:
    if num in num_dict:
        num_dict[num] += 1
    else:
        num_dict[num] = 1

print(num_dict)

“”"
重复的单词: 此处认为单词之间以空格为分隔符，并且不包含，和.；
# 1. 用户输入一句英文句子；
# 2. 打印出每个单词及其重复的次数;

“”"

  s = input('s:')
    # 1.把每个单词分割处理
    s_li = s.split()
    print(s_li)
    # 通过字典存储单词和改单词出现的次数
    word_dict = {}
    for item in s_li:
        if item not in word_dict:
            word_dict[item] = 1
        else:
            word_dict[item] += 1
    print(word_dict)

“”"
# 1. 随机生成100个卡号；
# 卡号以6102009开头，后面3位依次是（001， 002， 003， 100），
# 2. 生成关于银行卡号的字典，默认每个卡号的初始密码为"redhat";
# 3. 输出卡号和密码信息，格式如下:
卡号密码
6102009001 000000

“”"

 # print({}.fromkeys({'1','2'},'0000000'))

card_ids =[]
# 生成100个卡号
for i in range(100):
    # %.3d：代表整型数占3位
    s = '6102009%.3d' %(i+1)
    # 将每次生成的卡号都加入到列表中
    card_ids.append(s)

card_ids_dict = {}.fromkeys(card_ids,'redhat')
print(card_ids_dict)
print('卡号\t\t\t\t\t密码')
for key in card_ids_dict:
    print('%s\t\t\t%s' %(key,card_ids_dict[key]))