01Python基础阶段_Day04

01Python基础阶段_Day04

Python 官方中文文档
https://docs.python.org/zh-cn/3/

字符串常用方法

a.查找_替换_统计
find() 掌握 注意: 找不到子串时,返回-1
rfind() 了解
index() 了解 注意: 找不到子串时,程序会崩溃,产生一条异常信息,导致程序无法执行
rindex() 了解
replace() 掌握 默认全部替换
count() 掌握 计数统计

b. 分割_连接
split() 掌握 输出的是列表,需要注意有分隔符,且每个都会生效
splitlines() 理解 注意只识别换行为分隔符

​ partition() 了解 只会分割成三部分,且输出一个元组,保留分割的内容
​ rpartition() 了解 从右侧进行分割
​ join() 掌握 加入字符进行连接列表中的每个元素

c. 判断
startswith() 判断是否以指定字符串开头 （掌握）返回True Or False
endswith() 判断是否以指定字符串结束 （掌握）返回True Or False
isupper() 判断是不是大写字符 (理解)
islower() 判断是不是小写字符 (理解)
isdigit() 判断是不是数字字符 (理解)
isalpha() 判断是不是字母 (理解)
isalnum() 判断是不是字母或数字字符 (理解)
isspace() 判断是不是空白字符，包含空格，换行符\n，制表符\t (理解)注意’'空字符串不是空白字符

d. 转换 （理解）
upper() 转换成大写
lower() 转换成小写
title() 将每个单词首字符转换大写
capitalize() 将第一个单词的首字符转换成大写

e. 对齐 （理解）
center() 按给定宽度居中显示
rjust() 右对齐
ljust() 左对齐

f. 去除空白（理解）
strip() 去除两端空白
lstrip() 去除左侧空白
rstrip() 去除右侧空白

元组

a. 定义和下标访问
元组的格式: (值,…)
元组的类型: tuple
元组的下标使用同字符串

注意:如果元组中只有一个元素,那么在定义时,需要加一个逗号

元组元素不能修改

b. 遍历
for-in
t = (1,2,3,4,5,‘hello’)
for v in t:
print(v)

循环配合下标方式 一

​ for i in range(len(t)):
​ print(t[i])

循环配合下标方式 二

​ i = 0
​ while i < len(t):
​ print(t[i])
​ i += 1

​

c. 嵌套元组

​ t = (1, 2, 3, (4, 5, 6))

d. 常用方法
功能同字符串
count() 用来统计元素个数
index() 查找元素的位置索引,如果不存在会报错

​

列表

a. 定义和下标访问
定义格式:
变量名 = [值,…]
变量名 = list(值)
注意:如果列表中只有一个元素,那么在定义时,无影响

列表元素可以修改

下标:
0~len(列表名)-1

b. 遍历
同字符串或元组

c. 嵌套列表定义和遍历
isinstance(obj,type) -> bool

d. 排序和逆序
sort(reverse=False)
reverse()

e. 常用方法
增：
append()
extend()
insert()
修：
下标修改

​ 查：
​ index()
​ count()
​ in (掌握)
​ not in
​ 删：
​ pop（）
​ remove()
​ clear() 清空但列表存在
​ del 全没了

字典概述，定义

字典定义格式
{key: value,…}

字典的元素的引用

使用字典获取字典中的数据
格式:
字典变量名[key]
字典变量名.get(key)

遍历字典

四种遍历方式-看代码

字典增删改查

字典练习（名片管理）

函数一: 建立名片-> 建立好的名片
函数二: 显示名片-> 接收谁打印谁

无序字典和有序字典

在 python3.5之前， dict 类型是无序的 ，key无序，-> 写入顺序和显示顺序不同
在 pyhton3.5之后，都是有序

集合定义和引用

集合的特性：
集合定义像字典
存储数据像列表

重要特性:
集合中的数据不允许重复

作用：
利用集合的特性来对数据进行去除重复数据

定义：
set(可遍历的对象)

访问：

set-list-tuple三者类型间转换

公共方法和内置函数

上课部分代码

``

'''
字符串的常用方法
'''

# find()
s = "hello world hello python"


def test_find():
    # 找到匹配的第一个索引
    idx = s.find("o")
    print(idx)
    idx2 = s.find("o", 8)
    print(idx2)


test_find()


# rfind,rindex返回的从最后开始往前数的索引
def test_rfind_rindex():
    print(s.rfind("o"))
    print(s.rindex("o"))


print(len(s))
test_rfind_rindex()


# replace() 替换
def test_replace():
    # 默认替换所有符合的字符串
    s1 = s.replace("l", "L")
    print(s1)
    # 原来的字符串不变
    print(s)
    # 最后的参数3表示替换的个数，默认是all
    print(s.replace("l", "L", 3))


test_replace()


# split() 分割
def test_split():
    ret = s.split(" ")
    print(ret)
    print(type(ret))

    ss = "hello\t world\n hello\n python"
    # 如果在分割字符串时,需要使用任何空白进行分割,那么参数中,什么也不需要写
    print(ss.split())


test_split()


# join()使用当前字符串连接参数中的每个元素
def test_join():
    ss = 'hello world python'
    print('-'.join(ss))
    s_ss = ss.split()
    j_ss = '-'.join(s_ss)
    print(j_ss)


test_join()

# 去除空白
s = "   hello    python   "
print('|' + s.strip() + '|')
print('|' + s.lstrip() + '|')
print('|' + s.rstrip() + '|')

ret = s.split()
ret2 = ''.join(ret)
print(ret2.center(20))

# 元组的定义和下标使用
t1 = ()
print(t1)
print(type(t1))

t2 = (1, 2, 3, 4)
print(t2)

t3 = (1, 3.14, 'hello', True, t2)
print(t3)

# 定义具有一个元素的元组,特殊,注意不是元组了
t4 = (1)
print(t4)
print(type(t4))

# 使用类型名定义元组
t5 = tuple('hello')
print(t5)

# 元组的下标访问
t8 = (1, 2, 3, 4, 5)
print(t8[0])
# 元组不能使用超出范围的下标.同时也不能改变值

# 元组的遍历
t = (1, 2, 3, 4, 5, 'hello')
# 三种方式
for c in t:
    print(c)

for i in range(len(t)):
    print(t[i])

i = 0
while i < len(t):
    print(t[i])
    i += 1

# 元组的嵌套及遍历
t = (1, 2, 3, (4, 5, 6))
for c in t:
    print(c)

# 要求打印嵌套元组的内容
for c1 in t:
    # isinstance()判断参数一是否是参数二的类型对象
    # 通过判断,遍历的元素是不是一个元组
    if isinstance(c1, tuple):
        # 注意这里不是in t了,而是in c1,注意理解
        for c2 in c1:
            print(c2)
    else:
        print(c1)

# 列表的定义和下标访问
c11 = []
print(c11)
print(type(c11))

c13 = [1, 2, 3, 'hello', (1, 2, 3), ['a', 'b', 'c']]
print(c13)

# 遍历多元素列表
for c in c13:
    if isinstance(c, tuple) or isinstance(c, list):
        for i in c:
            print(i)
    else:
        print(c)

# 字符串逆序
s = 'hello'
print(s[::-1])


def revers_str(s):
    ret_s = ''
    i = len(s) - 1
    while i >= 0:
        ret_s += s[i]
        i -= 1
    return ret_s


print(revers_str(s))

# 列表的排序和逆序
c1 = [9, 2, 5, 6, 1, 4, 3, 0, 7]
# 排序,默认升序排序(从小到大),直接打印是None
print(c1.sort())
print(c1)
# 降序排序
print(c1.sort(reverse=True))
print(c1)

# 逆序
# 排序没有返回值
c1 = [9, 2, 5, 6, 1, 4, 3, 0, 7]
c1.reverse()
print(c1)

# 列表的增删改查
c1 = []
c1.append(1)
c1.append(2)
c1.append('hello')
print(c1)
c2 = ['a', 'b', 'c']
# 将一个表达元素加入
c1.extend(c2)
print(c1)

# 插入insert
# 再插入数据时,没有下标越界问题,如果指定下标超过元素正常范围,相当于追加
c13 = [1, 2, 3, 4, 5]
c13.insert(0, 999)
print(c13)
c13.insert(77, 666)
print(c13)

# 查找 in
print(2 in c13)

# 删除
c1 = [1, 3, 5, 7, 8, 91, 90]
# pop中的index参数可以不写,默认删除最后一个
c1.pop()
print(c1)
# 删除指定对象,当有多个相同时,只删除第一个
c1.remove(7)
print(c1)
# del c1将整个列表删除,查不到了,会报错,所以删下标
del c1[1]
print(c1)
# 清空列表元素
c1.clear()
print(c1)
# 在使用列表时,不要在循环遍历时删除元素,因为删除一个元素时,后一个元素会往前进,逃过一劫

# 定义字典
d = {}
print(d)
print(type(d))

# key一般情况下使用字符串类型的数据充当
# 理论上,所有不可变的类型都可以作为key
# 只要是可hash的对象都可以作为key
d = {1: "one", "2": "two"}
print(d)

# 访问字典中的元素
# 字典也是通过下标方式来访问元素,但是字典中没有索引,也就是,没有下标编号
# 字典通过下标中的括号书写key的方式来直接访问key所对应的值
print(d["2"])
# 字典也是一个可变类型
d["2"] = ["3"]
print(d)
print(d.get("2"))

# 字典元素的遍历
# 默认情况下,使用for-in遍历时,会将所有的key遍历出来
d = {"one": "星期一", "two": "星期二", "three": "星期三", "hahaha": "周末"}
for k in d:
    print(f'for-in:{k}- > {d[k]}')

# keys()方法
print(d.keys())
for k in d.keys():
    print(f'for-in:{k}- > {d[k]}')

# values()方法
print(d.values())
for v in d.values():
    print(f'values:{v}')

# items()
print(d.items())
for item in d.items():
    print(f'items:{item[0]} -> {item[1]}')

for k, v in d.items():
    print(f'item:{k} -> {v}')

# 字典的增删改查
# 如果在赋值时,使用的key在字典中不存在,那么就是在向字典中添加数据
# 如果存在,赋值就是修改对应的值,字典中的key具有唯一性
d = {}
d["a"] = 1
d["b"] = 2
print(d)

# 查
print(d["a"])
print(d.get("a"))

# 删除,默认删除最后一个键值对
d.popitem()
print(d)


# pop可以通过指定key可以删除任意位置的键值对,为空会报错

# 名片管理
# 定义字典的函数
def creat_card():
    # 使用字典来保存每张名片的数据
    card = {}
    card["name"] = input("请输入姓名:")
    card["age"] = input("请输入年龄:")
    card["address"] = input("请输入地址:")

    return card


# 显示名片字典内容函数
def show_card(card):
    for k in card:
        print(f'{k} : {card.get(k)}')


# 测试
show_card(creat_card())

# 定义一个集合
s = {1, 2, 3, 4, 5, 6, 7, 7, 7}
print(s)
# s={}这种是定义一个空字典
# 定义空集合
s = set()

# 集合不支持下标访问
s = {1, 2, 3, 4, 5, 6, 7, 7, 7}
for v in s:
    print(v)

#  set-list-tuple三者类型间转换
s = "hello"
l = list(s)
print(l)

# 集合存储时是无序的
print(set(l))

ll = str(l)
print(ll, '----', type(ll))
print("".join(l))