python之String

今日课程简介：
    一,字符串
    二,公共方法
    三,完整for语法
    四,名片系统管理(开场)
    
字典:
        定义:
        字典名 = {键:值,
                键:值,
                键:值,
                ....}
        键:对值的一个描述信息,自定义索引
        键和值对应关系
        
        取值:
        字典名[键]
        修改/增加:
        字典名[键]=新值 (键存在就修改,不存在就增加)
        删除:
        字典名.pop(键)=====>删除指定的值  键不存在报错
        
        其他操作:
        统计键值对的个数
        长度=len(需要统计的字典)==================>返回键值对的个数
        合并的操作:
        字典名.update(放入需要更新的字典)
        清空:
        字典名.clear()=====>清空所有内容
        
        遍历操作:
        for 变量 in 字典:
            变量====>键
            
        列表嵌套字典:
        列表名 = [{},{},{}...]
        for 变量 in 列表:
            变量=====> 变量={}  变量就是字典名
        
**************************************************************************
一,字符串(部分)：
    定义:
        1.字符串名 = ""  常规都用这个
        2.字符串名 = '' ======> '内容"内容"' =====>内容"内容" (了解)
        
        
        
        
    常见操作：
        取值:(常用)
            根据索引取数据:
            变量名[对应的索引]
            
            根据数据拿索引
            字符串.index(部分字符串)===========>返回字符串出现的索引,没有就不存在
            
            
        遍历:(常用)
        for 变量 in 字符串:
            变量=====>每次接受单个的字符
            
        例如:
        str = "abc de"
        for char in str:
            print(char)
            
        效果:
        a
        b
        c
        
        d
        e                
                   
        
        统计:(常用)
        1.len()====>统计字符串长度
        2.字符串.count(子字符串)=======>统计部分字符串出现的次数
        
        
            
        判断是否为空白字符(了解就可以)
        字符串.isspace()  是否只有空白字符    
            
        判断开头结尾(常用)
            1.判断开头:
                startswith(传入需要判断的数据)===========> 传入部分字符串 判断是否是开头
            
            2.判断结尾:
                endswith(传入需要判断的数据)========> 传入部分字符串 判断是否是开头
            
        查找和替换:(常用)
            1.find()
                参数:传入子字符串
                返回值:返回子字符串 出现的第一个位置
                例如:
                hello_str = "hello world"
                # index = hello_str.find("llo")
                # index = hello_str.find("llo2")  # 如果这个字符串不存在 就返回-1
                print(index)
            
            2.replace()
                参数: 参数1需要被替换的数据, 参数2用来替换的数据
                返回值:实现的效果
                
                例如:
                hello_str = "hello world" 
                new_str = hello_str.replace("he","HE")  # 会产生一个新的字符串 实现效果,因为源数据不能更改,看效果看返回值
                print(hello_str)
                print(new_str)
                
                注意:字符串源数据不能更改,例如 hello_str[0] = "H"  报错
            
            
            
            
        文本对齐(了解就可以):
            1.填充过后的字符串=center(宽度,填充字符)
            2.返回没有空白字符的数据=strip()======>不能去除中间的空白
            
            
        
        拆分和拼接:(常用)
            1.split():拆分
                参数:一定要写一个字符,一定在源字符串中的
                返回值:把每个字符串,除了参数,都放进列表中
            2.join():拼接
                参数:需要拼接的列表
                返回值:拼接之后的字符串
                
                注意:
                填充物.join()
                例如:
                char_list=["a","b","c"]
                result="|".join(char_list)
                print(result)======>"a|b|c"
        
        字符串切片:(重点常用)**
            变量名[开始:结束:索引差]
            开始:
                索引差为正数,默认为0
                索引差为负数,默认为-1
                例如:
                str = "abcde"
                str[::1]====>从头到尾
                str[::-1]====>倒着来
            结束:
                不包含写的索引
                str = "abcde"
                str[0:3:]=====>abc
            索引差:
                索引之间的差数
                索引差为负数 从右往左数
                索引差为正数 从左往右数
                例如:
                str = "abcdef"
                间隔2个元素取值
                0 1 2 3 4 5 6
                0 3 6====> 差数:3
                str[::3]
            
                
            
            
        
二,公共方法
    公共方法:
        1.切片
        2.len()
        3.del()
        4.max()
        5.min()
    
    算术运算符:
        +:
            把两个高级数据类型相加 产生一个新的数据
            new_tuple=(1,2)+(3,4)
            print(new_tuple)====>(1,2,3,4)
            ******************************************
            new_list=[1,2]+[3,4]
            print(new_list)====>[1,2,3,4]
            ******************************************
            str = "a"
            str2 = "b"
            new_str=str + str2
            print(new_str)===>"ab"
        *:
            重复高级数据类型,产生一个新的数据
            例如:
            num_list = [1,2]
            new_list = num_list*2
            print(new_list)====>[1,2,1,2]
        都不能用字典
    成员运算符:
        in:判断是否存在于 ...里面
        not in:判断是否不存在于...里面
        注意点:
            字典使用判断的是 键            
            
        
三,完整for语法

    语法格式:
        for 变量 in 数据:
            操作
        else:
            上面的循环正常结束,进入,如果有break 被执行了就不进来
    
    
        
    案例分析:
    students = [
    {"name": "阿土",
     "age": 20,
     "gender": True,
     "height": 1.7,
     "weight": 75.0},
    {"name": "小美",
     "age": 19,
     "gender": False,
     "height": 1.6,
     "weight": 45.0},
    ]
    需要根据name 找一个学员
    
        


四,名片系统管理(开场)

    1.输入和pass
        1.变量=用户输入
        2.判断录入的数据是什么
            if 变量 in ["1","2","3"]:
                pass # 占位符
            elif 变量=="0":
                退出
            else:
                输入错误
        
    2.无限循环
        因为程序需要一直跑,只能有用户输入0来中断
        while True
            变量=用户输入
            判断录入的数据是什么
                if 变量 in ["1","2","3"]:
                    pass # 占位符
                elif 变量=="0":
                    退出
                    1.break 
                else:
                    输入错误
        
        
    
    3.嵌套名片操作判断
        如果录入的是 1 or 2 or 3 就做一些判断
        
        while True
            变量=用户输入
            判断录入的数据是什么
                if 变量 in ["1","2","3"]:
                    # 1.进入这个缩进 说明可以错操作了
                    if 变量=="1":
                        pass
                    elif == "2":
                        pass
                    else:
                        pass
                elif 变量=="0":
                    退出
                    1.break 
                else:
                    输入错误
        
    
    4.TODO注释
        注释还没有完成的功能
        语法: # TODO 注释内容
        
    5.欢迎界面
        1.在cards_tool.py文件 新建函数
        def show_menu():
            一堆输出语句
        2.main文件导包:import cards_tool
        3.调用函数:
        while True:
            cards_tool.show_menu()
    6.框架搭建完成
        1.在cards_tool.py文件 新建其他三个函数
            函数1:新建
            函数2:展示全部
            函数3:查询
            
        2.在之前的判断里面调用
            # 1.进入这个缩进 说明可以错操作了
                    if 变量=="1":
                        函数1:新建
                    elif == "2":
                        函数2:展示全部
                    else:
                        函数3:查询
    7.全局名片列表
    8.新增名片
    9.统一修改变量名
    10.显示所有名片
    11.判断名片数量    字符串的定义
双引号，单引号，三引号，\'，\"
单双引号穿插，字符串中有双引号时，用单引号定义字符串

常见操作：
    取值：str[index]
    遍历：for variable in str:
    统计：len(str)
         str.count(subString)   #没有的话返回0
    字符串出现的位置：str.index(char)  #不存在就报错  ???????????????????????????????
                    放在最后一排，Process finished with exit code 1
                    放在中间的话错误会显示出来，有时也不显示，但后面的代码不会运行
        str.index(str, beg=0, end=len(string))
    判断是否为空白字符：
    判断开头结尾：

    判断数字
单个字符在python中也是作为字符串使用
截取字符串str[start:end]
转义字符\\  \'  \"  \a响铃  \b退格



    查找字符串的位置str.find(substring,start,end)
    替换字符串：字符串不允许对原有的数据进行修改，但可以重新赋值str="aa"   str="bb"   先把"aa"赋值给变量str,后来把"bb"赋值给str
                        str+=str1
    str.replace(old,new,count)

    去除空格str.strip()
    字符串文本对齐str="hello"  new=str.center(30,"+")

    打印一首诗

    split()
    char_list=["a","b"]
    str="".join(char_list)
    str="+".join(char_list)  #用调用的字符串对列表的每个元素进行拼接
========================================================================下午下午
拆分与拼接
1、split
str.split()拆分成列表，没有参数的话整个字符串作为列表中的一个元素
2、join()拼接
    参数，需要拼接的列表
    返回值：拼接之后的字符串

切片:
    切片也是公共方法：切片就是一种取值规则
公共方法：切片、len、max、min、del
公共运算符
    * + in not in

循环是条件满足时循环
遍历是遍历iterator
//////////////////////////////////////////////////////
1、掌握python中字符串的定义格式
2、能够使用下标来获取字符串中的某个字符
3、能够使用切片来获取字符串中的一些字符
4、能够使用切片完成字符串逆序
5、使用str.split方法完成切割字符串
6、使用+号运算符实现字符串拼接
7、使用str.join方法实现字符串拼接
8、使用str.find方法完成查找子串操作
9、使用str.replace方法完成子串替换
10、使用str.strip方法完成去除字符串两边空格操作
11、使用for遍历字典
12、能够完成字典,字符串,列表及元组的遍历
//////////////////////////////////////////////////////////记忆
字符串：字符串的定义、改变、拼接、replace；计算统计len、数量count；取值、遍历；
        判断开始结束startswith_endswith，定位index、find，去除空格strip，文本对齐center；


/////////////////////////////我的String笔记
字符串的常用操作及其分类
        判断类型isspace/isalnum/istitle/islower/isupper
        查找和替换startswith/endswith/index/rindex/find/rfind/replace
        大小写转换capitalize/title/lower/upper/swapcase
        去除空白lstrip/rstrip/strip文本对齐ljust/rjust/center
        拆分和连接partition/rpartition/split/splitlines/join

字符串的切片：字符串、列表、元组，字符串[开始索引:结束索引:步长]
            截取0~5位置，-2的含义，倒序
完整的for循环
    for 变量 in 集合:
        循环体代码
    else:
        没有通过 break 退出循环，循环结束后，会执行的代码
公共方法

else的用法
公共方法< =...

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

字符串运算符
操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	'H' in a 输出结果 1
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	'M' not in a 输出结果 1
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	`print( r'\n' ) print( R'\n' )`
%	格式字符串	请看下一节内容。

字符串格式化符号
符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令
符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
	Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

字符串内建函数
序号	方法及描述
1	capitalize() 将字符串的第一个字符转换为大写
2	center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3	count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4	bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5	encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6	endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7	expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8	find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9	index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10	isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
11	isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12	isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13	islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14	isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15	isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
16	istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17	isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18	join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19	len(string) 返回字符串长度
20	ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21	lower() 转换字符串中所有大写字符为小写.
22	lstrip() 截掉字符串左边的空格或指定字符。
23	maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24	max(str) 返回字符串 str 中最大的字母。
25	min(str) 返回字符串 str 中最小的字母。
26	replace(old, new [, max]) 把将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27	rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28	rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29	rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30	rstrip() 删除字符串字符串末尾的空格.
31	split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
32	splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33	startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34	strip([chars]) 在字符串上执行 lstrip()和 rstrip()
35	swapcase() 将字符串中大写转换为小写，小写转换为大写
36	title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37	translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38	upper() 转换字符串中的小写字母为大写
39	zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40	isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

hello_str.capitalize    hello_str.isidentifier  hello_str.rindex
hello_str.casefold      hello_str.islower       hello_str.rjust
hello_str.center        hello_str.isnumeric     hello_str.rpartition
hello_str.count         hello_str.isprintable   hello_str.rsplit
hello_str.encode        hello_str.isspace       hello_str.rstrip
hello_str.endswith      hello_str.istitle       hello_str.split
hello_str.expandtabs    hello_str.isupper       hello_str.splitlines
hello_str.find          hello_str.join          hello_str.startswith
hello_str.format        hello_str.ljust         hello_str.strip
hello_str.format_map    hello_str.lower         hello_str.swapcase
hello_str.index         hello_str.lstrip        hello_str.title
hello_str.isalnum       hello_str.maketrans     hello_str.translate
hello_str.isalpha       hello_str.partition     hello_str.upper
hello_str.isdecimal     hello_str.replace       hello_str.zfill
hello_str.isdigit       hello_str.rfind

判断类型
方法	说明
string.isspace()	如果 string 中只包含空格，则返回 True
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True，`全角数字`
string.isdigit()	如果 string 只包含数字则返回 True，`全角数字`、`⑴`、`\u00b2`
string.isnumeric()	如果 string 只包含数字则返回 True，`全角数字`，`汉字数字`
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

查找和替换
方法	说明
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回`-1`
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

大小写转换
方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.swapcase()	翻转 string 中的大小写

文本对齐
方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.swapcase()	翻转 string 中的大小写

去除空白
方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

拆分和连接
方法	说明
string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格
string.splitlines()	按照行('\r', '\n', '\r\n')分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

=======================

公共方法之python内置函数
函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较
cmp(item1, item2)	比较两个值，-1 小于/0 相等/1 大于	Python 3.x 取消了 cmp 函数

公共方法之运算符
运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	["Hi!"] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 3) < (2, 2, 3)	True	元素比较	字符串、列表、元组

公共方法之成员运算符
运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	`3 in (1, 2, 3)` 返回 `True`
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	`3 not in (1, 2, 3)` 返回`False`