Python【day2】：Python入门(python分类、编码方式、数据类型列表、字典、字符串、元组、整数、浮点数等介绍)

pycharm小技巧：

pycharm连接github方法：
1、想要将pycharm的源代码上传到github上的时候：
第一步：vcs菜单-commit changes；
第二部：vcs菜单-git-push；

 

python版本的分类
1、cpython 　　　　1c解释器       2.pyc(字节码) 3转换机器码 4cpu调用执行    编译过程（12） 执行过程（34） 执行过程包含转换成机器码 （应用最广泛）
2、jpython             2java解释器  2java字节码    3机器码 　　4cpu调用执行
3、ironpython         3c#解释器    2c#字节码      3机器码 　　4cpu调用执行
4、ruby python
5、js  python
6、pypy                1解释器        2字节码     3编译成机器码   4执行的过程，直接执行机器码  

                           编译过程(123)  执行4 这里执行过程只包含步骤4，所有比较快

 

编码方式

ascii、unicode 、utf-8的区别

1、ascii：其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。

2、Unicode：（统一码、万国码、单一码） 规定所有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，

缺点：ascii码中的内容也是用2个字节保存，这个浪费了内存或存储空间
注：此处说的的是最少2个字节，可能更多

3、UTF-8：是对Unicode编码的优化，他不再使用最少使用2个字节，

ascii码中的内容用1个字节保存、（避免的unicode 用2个字节保存，浪费空间的情况）

欧洲的字符用2个字节保存，

东亚的字符用3个字节保存...

python 2.7默认是ascii编码，显示中文，需要编码声明

python 3.5默认是utf-8编码，显示中文，不需要编码声明

上述3个编码方式的转换--见下图

unicode：编码encode变成utf8
utf8：解码decode变成unicode

 

数字、字符串的缓冲池概念

1、数字中-5~257这些数，会存在缓冲池中，就是这些数字每次不需要重复在内存中创建，会在缓存中放着，节约内存空间；

2、字符串也会按照一个内存的算法，将最常用的字符串存在缓冲池，这样这些常见字符串每次不需要重复在内存中创建，会在缓存中放着，节约内存空间；

 

主入口程序

例子1：
模块1（py文件）test.py       
模块2（py文件）lib/3.py   

模块3（py文件） index.py

上述3个模块，模块3中导入了模块1和模块2，执行模块3的时候：

模块1.__name__ == test

模块2.__name__ == 1ib.3

模块3.__name__ == "__main__"

如果想要模块3被别的模块导入的时候，不执行，只有模块3是入口程序，或者执行模块3，它才执行，可以在模块3中这么写：
if __name__ == "__main__"

 

 

例子2：

#内置函数 __name__
# def f1():
#     pass
# def f2():
#     pass
# if __name__ == "__main__":
#     f1()     #意思是这样当前模块是执行入口的时候，f1函数才会调用，如果当前模块是被别的模块导入的话，f1函数不会被调用

中断循环

break  　　跳出整个循环
continue  跳出当次迭代
pass      啥都不干，占位，语法检查
return    函数返回
exit      退出整个程序 sys.exit()

包含
in
__contains__

 

with不需要关闭文件的原理

#with open("1.txt") as f

# import contextlib
# @contextlib.contextmanager  #装饰器管理上下文（线程池：计算线程多少活跃，多少等待）
# def show():
#     print("123")  #打开文件
#     yield
#     print("456")  #关闭文件
# with show():
#     print("99999")  #写文件

# 输出
# 123
# 99999
# 456

 

基本数据类型

一切事物都是对象，对象由类来产生，见下图

新建一个列表[1,2,3]，列表是对象，列表由list类来产生，列表的内置方法都存在list类中；字符串、元组、字典等都是这个原理

type(变量名)：可以查看变量的数据类型（str\list\diac\tuple还是别的数据类型）

dir(变量名)：可以查看该变量所在的类中，包含哪些内置方法

 

字符串

字符串在内存中的存储方式：
字符串"alex"是内存中连续的空间，如果想要将"alex"变成"alexy","alexy"是会在内存中再开辟一个内存空间

而不是在原来的"alex"后面再存储一个字符"y"

由于上述原因，需要用格式化拼接字符串，避免用+拼接字符串（这样会重复开辟内存空间，性能低）

 

列表

__author__ = 'Administrator'
# -*- coding:utf-8 -*-

#定义列表的两种方式
li = [1,2,3]  #注意:模块(py文件)名字、变量名字都不能是list，否则会把list类覆盖
li = list([1,2,3]) #通过list类，创建对象实例li
li1 = list((4,5,))
# li = [1,2,3]
print(type(li))
print(dir(li))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__',
 '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__',
 '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__',
 '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
 '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',
 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

#不带两个下划线的方法
#1添加元素
li = [1,2,3]
li.append("4")  #添加元素"4"到列表的最后
print(li)  #[1, 2, 3, '4'] 这里"4"是字符串，前面的1,2，3都是数字

#2清空列表
li = [1,2,3]
li.clear()  #清空列表中的所有元素
print(li)  #[]

#3拷贝
# 浅拷贝，只拷贝列表的第一层，其余更深层就不拷贝了
# 深拷贝，会拷贝所有的层

#4计算元素在列表出现的次数
li = [1,2,3,3,5,3,3]
print(li.count(3))  #4  数字3在列表一共出现4次

#5合并第二个列表到第一个列表
li = [1,2,3]
li1 = [4,5]
li.extend(li1)
# print(li.extend(li1))  打印这个会报错，由于li列表发生了变化
print(li) #[1, 2, 3, 4, 5]

#5-1合并元组到列表
li = [1,2,3]
tu = (4,5,999)
li.extend(tu)
print(li)  #[1, 2, 3, 4, 5, 999]


#6返回列表中元素的索引号
li = ["a","b","c",1,2,3]  #这里abc必须加上引号，表示字符串，不加引号，表示变量
print (li.index("a"))  #0  元素"a"的索引号是0
# print (li.index("a1"))  #会报错 ValueError: 'a1' is not in list （由于"a1"不在列表中）
# print (li.index("c",0,2)) #[0,2)  这里取值范围是左闭右开，所有在索引号是0,1的元素中找不到"c"，会报错
print (li.index("c",2))  #2  "c"的索引号是2 取值范围，从索引号是2开始，一直到列表最后
 # L.index(value, [start, [stop]]) -> integer -- return first index of value.
 #        Raises ValueError if the value is not present.

#7给列表中指定位置，插入新的元素
li = ["a","b","c",1,2,3]
li.insert(0,"x")  #给索引号是0的位置，插入新的元素"x"
print(li.insert(0,"x")) #None,由于列表li发生了变化
print(li)  #['x', 'a', 'b', 'c', 1, 2, 3]

#8删除元素并返回这个被删除的元素（默认是最后一个，可以指定索引号删除）
li = ["a","b","c",1,2,3]
print(li.pop()) #3 不带参数，默认删除最后一个元素并返回该元素
print(li)  #['a', 'b', 'c', 1, 2]

li = ["a","b","c",1,2,3]
print(li.pop(2)) #3 带参数，删除索引号是2的元素并返回该元素
print(li)  #['a', 'b', 1, 2, 3]

li = ["a","b","c",1,2,3]
li1 = []
# print(li.pop(6)) #报错 IndexError: pop index out of range 索引越界，没有索引号是6的元素，最大的索引号是5
# print(li1.pop()) #报错  IndexError: pop from empty list 不能从空列表删除元素
print(li)
# L.pop([index]) -> item -- remove and return item at index (default last).
#         Raises IndexError if list is empty or index is out of range.

 # 'remove', 'reverse', 'sort'
#9删除元素-指明元素值删除
li = ["a","b","b","c",1,2,3]
li.remove("b")  #删除原始"b"，有2个相同的元素"b"，删除左边第一个
# li.remove("e") #报错，如果要删除的元素不存在，ValueError: list.remove(x): x not in list
print("remove",li)  #['a', 'b', 'c', 1, 2, 3]
# L.remove(value) -> None -- remove first occurrence of value.
#         Raises ValueError if the value is not present.

#10删除元素-根据索引号删除
li = ["a","b","b","c",1,2,3]
del li[1] #删除列表中索引号是1的元素
print(li) #['a', 'b', 'c', 1, 2, 3]

#11反转倒置
li = ["a","b","b","c",1,2,3]
li.reverse()  #将列表的元素反转
# print(li.reverse())#None 因为反转后li已经改变了
print(li)  #[3, 2, 1, 'c', 'b', 'b', 'a']

#12排序-升序
li = [11,22,33,44,55,66,77,88,99,90]
li1 = ["d","a","b","b","c"]
li3 = ["a","b","b","c","1","2","3"]
# li2 = ["a","b","b","c",1,2,3]
li.sort()
li1.sort()
# li2.sort()
li3.sort()
# print(li.sort())
print(li)  #  数字可以排序[11, 22, 33, 44, 55, 66, 77, 88, 90, 99]
print(li1) # 字符串可以排序 ['a', 'b', 'b', 'c', 'd']
# print(li2)  #报错 数字和字符串混合不能排序 TypeError: unorderable types: int() < str()
print(li3) #字符串可以排序 ['1', '2', '3', 'a', 'b', 'b', 'c'] 这里'1', '2', '3'是字符串，而不是数字

#13排序-倒序-安照ascii
li = [11,22,33,44,55,66,77,88,99,90]
li1 = ["a","b","b","c","1","2","3"]
li.sort(reverse=True)
li1.sort(reverse=True)
print(li)  #数字倒序排列[99, 90, 88, 77, 66, 55, 44, 33, 22, 11]
print(li1) # 字符串倒序排列['c', 'b', 'b', 'a', '3', '2', '1']

#14判断列表中是否包含某个元素
li = [11,22,33,44,55,66,77,88,99,90]
print(li.__contains__(11))  #True 判断列表中是否包含某个元素
print(11 in li) #True  判断元素11是否在列表中

#15列表的长度
li = [11,22,33,44,55,66,77,88,99,90]
print(len(li)) #10 列表中含有10个元素(调用__len__()方法)
print(li.__len__()) #10 列表中含有10个元素

 

字典

#创建字典的2个方式
dic ={"k1":"v1","k2":"v2"}
dic1 = dict(k1="v1",k2="v2")
# dic3 ={k1:"v1",k2:"v2"} #报错 这个方式 key必须加双引号 NameError: name 'k1' is not defined
# dic2 = dict("k1"="v1","k2"="v2")  #报错 这个方式 key不能加双引号SyntaxError: keyword can't be an expression
print(dic1) #{'k1': 'v1', 'k2': 'v2'}
print(dic) #{'k1': 'v1', 'k2': 'v2'}
# print(dic2)
# print(dic3)

print(type(dic)) #<class 'dict'> 打印当前变量的数据类型
print(dir(dic)) #打印字典中含有的方法
print(dir(dict))#
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__',
 '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
 '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear',
 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

#1-1添加元素到字典，value是字符串
dic0 = {}  #定义空字典
dic ={"k1":"v1","k2":"v2"}
dic["k3"] = "v3"# 将键值对"k3":"v3"添加到字典  这里key和value都需要双引号，表示字符串，不加上引号就是变量
#注意：往列表追加元素是append方法；往字典添加键值对，没有内置方法，直接给key赋值就可
print(dic) #{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}  字典是无序了，没有索引号，通过key来定位

#1-2添加元素到字典，value是列表
dic0 = {}  #定义空字典
dic ={"k1":"v1","k2":"v2"}
dic["k3"] = [1,2,3]# 将键值对"k3":[1,2,3]添加到字典
print(dic) #{'k2': 'v2', 'k1': 'v1', 'k3': [1,2,3]}

#1-3添加元素到字典，value是字典
dic0 = {}  #定义空字典
dic ={"k1":"v1","k2":"v2"}
dic["k3"] = {"k4":"v4"}# 将键值对"k3":{"k4":"v4"}添加到字典
print(dic) #{'k2': 'v2', 'k3': {'k4': 'v4'}, 'k1': 'v1'}

#1-4添加元素到字典，value是字典
dic0 = {}  #定义空字典
dic ={"k1":"v1","k2":"v2"}
dic["k3"] = {"k3":"v3"}# 将键值对"k3":{"k3":"v3"}添加到字典,不同层次，2个k3，key相同是允许的
print(dic) #{'k1': 'v1', 'k2': 'v2', 'k3': {'k3': 'v3'}}

#2 不允许key相同
dic0 = {}  #定义空字典
dic ={"k1":"v1","k1":"v2"} #当key相同的时候，第一个key的vaue会被第二个key覆盖，不允许key相同
print(dic) #{'k1': 'v2'}

#3-1根据字典key取出value
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
dic2 = {'k1': 'v1', 'k2': 'v2', 'k3': [1,2,3]}
print(dic["k1"]) #v1 取出字典key-"k1"对应的value-"v1"
#注意：；列表通过索引号取元素li[0]，字典通过key取value---dic["k1"]
# print(dic["k5"])  #报错 KeyError: 'k5'
print(dic["k3"]["k4"]) #v4 取出字典key-"k3"对应的value-{'k4': 'v4'},再取出key-"k4"对应的value-"v4"
print(dic2["k3"][0]) #1  通过字典的key取出列表，通过列表的索引号取出列表元素

#3-2 通过key去取value，key如果不存在默认None，页可以返回指定的
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.get("k1"))  #v1  取出key-"k1"的value
print(dic.get("k5"))  #None  如果key-"k5"不存在，不会报错，默认返回None
print(dic.get("k5","test"))  #test  如果key-"k5"不存在，不会报错，指定返回"test"
# print(dic["k5"])  #报错 如果不用get方法，直接取值，如果key不存在，就报错# KeyError: 'k5'

#4取出字典的所有keys
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.keys()) #dict_keys(['k1', 'k3', 'k2']) 把字典的所有key取出存在一个列表中
# print(dic.keys()[0]) #报错 TypeError: 'dict_keys' object does not support indexing 字典是无序号的
for i in dic.keys(): #遍历字典的key
    print(i),
for i in dic: #遍历字典，也是默认输出key
    print(i),
for v in dic.values(): #遍历字典的values
    print(v),
for k,v in dic.items(): #遍历字典，输出key和value,这里必须是dic.items()方法
    print(k,dic[k]),  #这里的k不能加双引号

#5取出字典的所有values
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.values())  #dict_values(['v2', {'k4': 'v4'}, 'v1'])
print(type(dic.values()))  #<class 'dict_values'>
for v in dic.values(): #遍历字典的values
    print(v),

#6取出字典的所有key-value键值对
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
for k,v in dic.items():
    print(k,dic[k])

#7 以列表的元素作为字典的key，默认的value是None，也可以自定义value“test”
dic = dic.fromkeys(["k1","k2","k3"])
dic2 = dic.fromkeys(["k1","k2","k3"],"test")
print(dic)  #{'k2': None, 'k3': None, 'k1': None}
print(dic2) #{'k3': 'test', 'k1': 'test', 'k2': 'test'}

#8-1 删除键值对
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.pop("k1"))  #v1  删除k1:v1键值对，并且返回v1值
print(dic)  #{'k3': {'k4': 'v4'}, 'k2': 'v2'}

#8-2 删除键值对-删除不存在的key，不指定第二个参数就报错，指定了第二个参数，就返回第二个参数
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
# print(dic.pop("k5"))  #报错 key不存在的时候 KeyError: 'k5'
print(dic.pop("k5","k5不存在")) #k5不存在 如果k5不存在，返回指定的提示
print(dic)  #{'k3': {'k4': 'v4'}, 'k2': 'v2'}
 # D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 #        If key is not found, d is returned if given, otherwise KeyError is raised

#9  随机删除一个键值对
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.popitem())  #随机删除一个键值对
print(dic)

#10-1 给不存在的key赋默认值None
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.setdefault("k5")) #None k5这个key不存在，默认给k5赋值None
print(dic) #{'k2': 'v2', 'k5': None, 'k3': {'k4': 'v4'}, 'k1': 'v1'}

#10-2 给不存在的key赋默认自定义值
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(dic.setdefault("k5","test")) #test k5这个key不存在，默认给k5赋值"test"
print(dic) #{'k1': 'v1', 'k3': {'k4': 'v4'}, 'k5': 'test', 'k2': 'v2'}

#11 合并字典2到字典1中
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
dic2 = {'k5': 'v5'}
dic.update(dic2) #将字典dic2合并到字典dic中
print(dic)  #{'k2': 'v2', 'k5': 'v5', 'k3': {'k4': 'v4'}, 'k1': 'v1'}

#12包含
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print("k1" in dic) #True 判断key-"k1"是否在字典中
print(dic.__contains__("k1")) #True  判断字典是否包含key-"k1"

#13删除字典元素
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
dic.__delitem__("k1")  #删除指的键值对
print(dic) #{'k3': {'k4': 'v4'}, 'k2': 'v2'}

#14长度
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
print(len(dic))  #3  字典含有多少键值对

#15输出字典key和序号  列表的序号和元素
dic = {'k1': 'v1', 'k2': 'v2', 'k3': {'k4': 'v4'}}
for i,v in enumerate(dic):
    print(i,v)
li = ["a","b","c"]
for i,v in enumerate(li):
    print(i,v)

 

元组

#元组和列表的区别，元组的元素是不能修改（不能增加元素，不能删除元素，不能修改元素）的，
# 但是元组元素的元素是可以修改的
tu = (1,[1,2])
print(tu[1])  #[1, 2]  通过索引号取出元组的元素

#1修改元组的元素的元素
tu[1][0] = 3
print(tu) #(1, [3, 2])

#2修改元组的元素
# tu[0]=3
# print(tu) #报错 元组的元素不能修改 TypeError: 'tuple' object does not support item assignment

#创建元组的两种方式
tu = (1,2)
tu1 = tuple((1,2))
print(tu)
print(tu1)

print(type(tu)) #<class 'tuple'>
print(dir(tu1)) # 打印元组的内置方法
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__',
 '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__',
 '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
 '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
 'count', 'index']

#1计算元素在元组中出现的次数
tu = (1,2,2,3,4,2)
print(tu.count(2))  #3  数字2在元组中有3个

#2返回元素的索引号
tu = (1,2,2,3,4,2)
print(tu.index(4)) #4 数字4在元组中的索引号是4

 

字符串

#1创建字符串的两种方式
name = "jack"
name1 = str("jack")
print(name)
print(name1)

print(type(name)) #<class 'str'>
print(dir(name)) #打印字符串中包含的内置方法
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__',
 '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__',
 '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
 '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format',
 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower',
 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip',
 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

#0查看内置方法帮助文档的方法：按住ctrl键，鼠标移到方法名字上，鼠标变成小手，左键单击即可跳到帮助处

#1字符串首字符大写
name = "jack"
print(name.capitalize()) #Jack

#2-1大写字母转小写字母
name = "JAck"
print(name.casefold()) #jack

#2-2大写字母转小写字母
name = "JAck"
print(name.lower()) #jack

#3-1居中对齐，两边填充特殊符号
name = "jack"
print(name.center(20)) #        jack           一共20个字符，两边默认用空格填充，可以用于做字段居中对齐（购物清单）
print(name.center(20,"*")) #********jack********  一共20个字符，两边用星号*填充，可以用于做分隔线
# S.center(width[, fillchar]) -> str
#         Return S centered in a string of length width. Padding is
#         done using the specified fill character (default is a space)

#3-2左对齐，右边填充特殊符号
name = "jack"
print(name.ljust(20)) #jack                     一共20个字符，右边默认用空格填充，可以用于做字段左对齐（购物清单）
print(name.ljust(20,"=")) #jack================  一共20个字符，右边用等号=填充，可以用于做分隔线

#3-3右对齐，左边填充特殊符号
name = "jack"
print(name.rjust(20)) #                jack     一共20个字符，左边默认用空格填充，可以用于做做字段右对齐（购物清单
print(name.rjust(20,"!")) #  !!!!!!!!!!!!!!!!jack  一共20个字符，左边用叹号!填充，可以用于做分隔线

#3-4右对齐，左边填充数字0
name = "1111"
print("***",name.zfill(20))  #00000000000000001111 一共20个字符，左边默认用0填充

#4计算字符串中字符出现的次数
name = "jackaa"
print(name.count("a")) #3 返回字符"a"在字符串中出现的次数是3
print(name.count("a",2)) #2 作用范围：索引号2或者2以后，字符"a"在这个范围中出现的次数是2
print(name.count("a",1,4)) #1 作用范围：[1,4) 左闭右开，字符"a"在这个范围中出现的次数是1
# S.count(sub[, start[, end]]) -> int

#5-1是否以某个字符（或者字符子串）开头
name = "jackaa"
print(name.startswith("j")) #True  字符串是否以字母"j"开头
print(name.startswith("ja")) #True  字符串是否以字符串"ja"开头
print(name.startswith("j",1)) #False   作用范围：索引号1或者1以后，字符串是否以字母"j"开头
print(name.startswith("j",1,4)) #False  作用范围：[1,4) 左闭右开，字符串是否以字母"j"开头
# S.endswith(suffix[, start[, end]]) -> bool

#5-2是否以某个字符（或者字符子串）结尾
name = "jack"
print(name.endswith("k")) #True  字符串是否以字母"k"结尾
print(name.endswith("ck")) #True  字符串是否以字符串"ck"结尾
print(name.endswith("k",1)) #True   作用范围：索引号1或者1以后，字符串是否以字母"k"结尾
print(name.endswith("k",1,3)) #False  作用范围：[1,3) 左闭右开，字符串是否以字母"k"结尾
# S.endswith(suffix[, start[, end]]) -> bool

#6 将字符串中的tab \t用8个空格替换
name = "ja\tck"
print(name.expandtabs())  #ja      ck 将字符串中的tab--\t用8个空格代替，用于批量去掉配置文件中的tab

#7-1 索引，返回字符的索引号(找不到，返回-1)
name = "jack"
print(name.find("a")) #1  返回字符a的索引号
print(name.find("ac")) #1 返回字符串ac中的a的索引号
print(name.find("ac",1)) #1  作用范围：索引号1或者1以后，返回字符串ac中的a的索引号
print(name.find("al",0,2)) #-1 作用范围：[0,2) 左闭右开,返回字符串al中的a的索引号,如果没有该字符，就返回-1
# S.find(sub[, start[, end]]) -> int#
#         Return the lowest index in S where substring sub is found,
#         such that sub is contained within S[start:end].  Optional
#         arguments start and end are interpreted as in slice notation.#
#         Return -1 on failure.

#7-2 索引，返回字符的索引号(找不到，报错)
name = "jack"
print(name.index("a")) #1  返回字符a的索引号
print(name.index("ac")) #1 返回字符串ac中的a的索引号
print(name.index("ac",1)) #1  作用范围：索引号1或者1以后，返回字符串ac中的a的索引号
# print(name.index("al",0,2)) #-1 作用范围：[0,2) 左闭右开,返回字符串al中的a的索引号,
# 如果没有该字符，就报错，提示没有找到 ValueError: substring not found
# S.index(sub[, start[, end]]) -> int
#         Like S.find() but raise ValueError when the substring is not found.

#8-1 字符串格式化
info = "name {0},age {1}" #定义占位符
print(info.format("tom","19")) #name tom,age 19  给占位符传入实参
info1 = "name {0}"
print(info1.format("tom")) #name tom

#8-2 字符串格式化 %s %d %f
name = "jack"
print("welcome",name) #welcome jack
print("welcome %s,please" % name) #welcome jack,please
print("%s is %s years old" % (name,19)) #jack is 19 years old

#9 连接列表中的多个元素，用连接符
li = ["a","b","c"]
print("_".join(li)) #a_b_c 用连接符号"_"下划线，连接列表中的3个元素
print("".join(li)) #abc
print("|".join(li)) #a|b|c 用连接符号"|"竖线，连接列表中的3个元素
print(";".join(li)) #a;b;c 用连接符号";"分号，连接列表中的3个元素

li1 =["jack|123|0","tom|123|0"]
print("\n".join(li1))    #tom|123|0  用连接符号\n换行符，连接列表的2个元素，形成2行
# S.join(iterable) -> str
#         Return a string which is the concatenation of the strings in the
#         iterable.  The separator between elements is S.

#10 拆分
name = "jack|123|0"
print(name.split("|"))  #['jack', '123', '123'] 用"|"作为分隔符，将字符串拆分后，3个字符串作为列表的3个元素
print(name.split("|",1)) #['jack', '123|123'] 用左边第一个"|"作为分隔符，将字符串拆分成2部分，2个字符串作为列表的2个元素
print(name.split())  #['jack|123|0']
print(name.split(" ")) #['jack|123|0']
print(list(name))  #['j', 'a', 'c', 'k', '|', '1', '2', '3', '|', '0']

name1 = "jack 123 0"
print(name1.split()) #['jack', '123', '0']  默认以空格作为分隔符，将字符串拆分后，3个字符串作为列表的3个元素
print(name1.split(" ")) #['jack', '123', '0']  指定以空格作为分隔符
print(name1.split(" ",1)) #['jack', '123 0']  指定以左边第一个空格作为分隔符
# S.split(sep=None, maxsplit=-1) -> list of strings
#         Return a list of the words in S, using sep as the
#         delimiter string.  If maxsplit is given, at most maxsplit
#         splits are done. If sep is not specified or is None, any
#         whitespace string is a separator and empty strings are
#         removed from the result.

# 10-2 拆分
name = "jack 123 0"
print(name.partition("123"))  #('jack ', '123', ' 0') 以123作为分隔符将字符串拆分成3部分，中间那部分是分隔符本身
print(name.partition("1234")) #('jack 123 0', '', '')
# S.partition(sep) -> (head, sep, tail)
#         Search for the separator sep in S, and return the part before it,
#         the separator itself, and the part after it.  If the separator is not
#         found, return S and two empty strings.

#10-3 拆分行
name = "jack 123 0\ntom 123 0"
print("=====",name.splitlines()) #===== ['jack 123 0', 'tom 123 0'] 默认以换行符作为分隔符，拆分成2个字符串，作为列表的2个元素
print("=====",name.splitlines(2)) #===== ['jack 123 0\n', 'tom 123 0'] 拆分成2个字符串，作为列表的2个元素,第一个字符串包含换行符
 # S.splitlines([keepends]) -> list of strings
 #        Return a list of the lines in S, breaking at line boundaries.
 #        Line breaks are not included in the resulting list unless keepends
 #        is given and true.



#11 去空格或者换行符（去两端）
name = "jack 123 0 "
name1 = "\njack 123 0\n"
name2 = "3 0jack 123 0"
name3 = "0jack 123 0"
print(name.strip()) #jack 123 0 两端的空格被去掉了
print(name1.strip()) #jack 123 0 两端的换行符\n被去掉了
print(name3.strip("0")) #jack 123  两端的"0"被删除
print(name2.strip("3 0")) #jack 12  两端的"3 0"被删掉了
# S.strip([chars]) -> str
#         Return a copy of the string S with leading and trailing
#         whitespace removed.
#         If chars is given and not None, remove characters in chars instead.

#11-2 去空格或者换行符（去右边）
name = "jack 123 0 "
name1 = "jack 123 0\n"
name2 = "jack 123 0"
name3 = "jack 123 0\t"
print(name.rstrip())  #jack 123 0 去掉右边的空格
print(name1.rstrip()) #jack 123 0 去掉右边的换行符
print(name2.rstrip("0")) #jack 123 去掉右边的字符串"0"
print(name3.rstrip()) #jack 123 去掉右边的tab键
# print(name2.rstrip(0))  #报错 参数不能是数字，得是字符串 TypeError: rstrip arg must be None or str

#11-3 去空格或者换行符（去左边）
name = " jack 123 00 "
name1 = "\njack 123 0"
name2 = "jack 123 0"
name3 = "\tjack 123 0"
print(name.lstrip())  #jack 123 00  去掉最左边的空格
print(name1.lstrip()) #jack 123 0 去掉最左边的换行符
print(name2.lstrip("j")) #ack 123 0 去掉右边的字符串"j"
print(name2.lstrip("ja")) #ck 123 0 去掉右边的字符串"ja"
print(name3.lstrip()) #jack 123 0去掉最左边的tab键

#12替换
name = "jack 123 00"
name1 = "jack 00 123 00"
name2 = "jack 00 123 00 12 00"
print(name.replace("00","01")) #jack 123 01
print(name1.replace("00","01")) #jack 01 123 01
print(name1.replace("00","01",1)) #jack 01 123 00 第三个参数1表示只替换左边第一个"00"
print(name2.replace("00","01",2)) #jack 01 123 01 12 00  第三个参数2表示只替换左边前2个"00"
# S.replace(old, new[, count]) -> str
#         Return a copy of S with all occurrences of substring
#         old replaced by new.  If the optional argument count is
#         given, only the first count occurrences are replaced.
#         """

#13-1大小写互换
name = "jack TOM"
print(name.swapcase()) #JACK tom
 # S.swapcase() -> str
 #        Return a copy of S with uppercase characters converted to lowercase
 #        and vice versa.

#13-2 每个单词首字母大写
name = "jack bob"
print(name.title()) #Jack Bob
 # S.title() -> str
 #        Return a titlecased version of S, i.e. words start with title case
 #        characters, all remaining cased characters have lower case.

#13-3 小写全部转大写
name = "jack bob"
print(name.upper()) #JACK BOB
 # S.upper() -> str
 #        Return a copy of S converted to uppercase.

 #13-4 大写全部转小写
name = "JACK BoB"
print(name.lower()) #jack bob

#14-1包含in
name = "jack bob"
print("a" in name) #True  字符"a"是否在字符串中

#14-2包含
name = "jack bob"
print(name.__contains__("a")) #True  字符串是否包含字符"a"

#15长度
name = "jack bob"
print(len(name)) #8 

 

# 课堂练习
# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，
# 将小于等于 66 的值保存至第二个key的值中。
# 即： {'k1': 大于66 , 'k2': 小于等于66}
# 预期结果： {'k1': [11, 22, 33, 44, 55, 66], 'k2': [11, 77, 88, 99, 90]}
# dic ={'k1': [], 'k2': []}

#踩过的坑：
# 1 事先把预期结果想好，再着手去做，就是需求要理解对（审题）
# 2 字典内含有列表（整体结构）,遍历列表，做判断
# 3 列表添加元素--append  （dic["k1"]代表列表，dic["k1"].append()）
# 4 字典添加元素（键值对）--直接赋值  dic["k1"] =[i,]

# #整体思路1 --方法12（好理解）
# 1先定义字典结构 dic ={'k1': [], 'k2': []}
# 2再遍历列表，判断大于 66 的数 添加append到dic["k2"]
#   小于等于 66 的数 添加append到dic["k1"]
# 3打印字典

# #整体思路2 --方法34（运用课堂知识）
# 1先定义空字典 dic ={}
# 2再遍历列表，判断大于 66 的数
#   再次判断"k2"是否在字典中，不在的话，创建键值对 dic["k2"] = [i,]；在的话添加append到dic["k2"]
#   小于等于 66 的数
#    再次判断"k1"是否在字典中，不在的话，创建键值对 dic["k1"] = [i,]；在的话添加append到dic["k1"]
# 3打印字典

# #整体思路3  --方法5（缺点：列表的元素多的，不实用；优点：列表的元素少的时候，简洁）
# 1 先定义空白字典
# 2 对列表sort排序
# 3 根据列表的索引号给字典的key赋值
#   dic["k1"] = li[0:6]
#   dic["k2"] = li[6:]
# 4 打印字典

# 方法1：
dic = {"k1":[],"k2":[]} #直接定义字典结构
li = [11,22,33,44,55,66,77,88,99,90]
for i in li:#遍历列表的数
    if i >66:
        dic["k1"].append(i)  #把大于66的数添加到空列表1  dic["k1"]指的是空列表[]
    else:
        dic["k2"].append(i)  #把小于等于66的数添加到空列表2  dic["k2"]指的是空列表[]
print(dic)  #{'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}

# 方法2：-65
dic = {} #定义空字典
li = [11,22,33,44,55,66,77,88,99,90]
dic["k1"] = []  #添加一个键值对（元素）
dic["k2"] = []  #添加第二个键值对（元素）
print(dic)  #{'k1': [], 'k2': []}  先把架子搭好
for i in li:#遍历列表的数
    if i >66:
        dic["k1"].append(i)  #把大于66的数添加到空列表1
    else:
        dic["k2"].append(i)  #把小于等于66的数添加到空列表2
print(dic)  #{'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}

#方法3：
dic = {} #定义空字典
li = [11,22,33,44,55,66,77,88,99,90]
for i in li:
    if i>66:
        if "k2" in dic:
            dic["k2"].append(i)
        else:
            dic["k2"] =[]
    else:
        if "k1" in dic:
            dic["k1"].append(i)
        else:
            dic["k1"] =[]  #如果这里是空列表，那么列表中会少11和77两个值,没有实现需求
print(dic)  #{'k2': [88, 99, 90], 'k1': [22, 33, 44, 55, 66]}

#方法4：ws
dic = {} #定义空字典
li = [11,22,33,44,55,66,77,88,99,90]
for i in li:
    if i>66:
        if "k2" in dic:
            dic["k2"].append(i)
        else:
            dic["k2"] =[i,]
    else:
        if "k1" in dic: #22进来
            dic["k1"].append(i)  #往字典的value的列表中添加元素
        else:  #1 11进来
            dic["k1"] =[i,] #2 创建一个键值对（value不是空列表），这里value是列表的形式
print(dic)  #{'k1': [11, 22, 33, 44, 55, 66], 'k2': [77, 88, 99, 90]}


#方法5： sj
dic ={}  #定义空字典
li = [11,22,33,44,55,66,77,88,99,90]
li.sort()  #排序
dic["k1"]=li[0:6]  #'k1': [11, 22, 33, 44, 55, 66]  列表的元素少，可以用这个方法，多了就不适用了
dic["k2"]=li[6:]  # 'k2': [77, 88, 90, 99]
print(dic)  #{'k1': [11, 22, 33, 44, 55, 66], 'k2': [77, 88, 90, 99]}