python基础之周末小结

一、与用户交互

1.获取用户输入

   input
  # 获取用户输入
  username = input('请输入您的用户名>>>:')

强调:input获取到的数据都会统一处理成 # 字符串类型

2.输出内部信息

 print()
   1）括号内既可以放数据值，也可以放变量名，并且支持多个数据值或者变量名，用逗号隔开即可
   2） print 自带换行符
  # 换行符：\r\n 或者\n（斜杠与字母组合可能会产生特殊含义）
   3） print也可以切换结束符
       print(数据，end='默认是\n')

二、格式化输出

提前定义好一些内容,将来需要使用的时候可以局部修改与填写

 1.代码实现
	在现实生活中大部分情况下使用下划线提示别人填写内容
 	但是在程序中需要使用占位符:%s %d
2.不同占位符的区别
# %s常见数据类型都支持
  demo1 = '%s您好 您本月的话费是%s 余额是%s' 
  print(demo1 % ('jason', 100, 1))
# %d只支持数字类型
  demo2 = '%d您好 您本月的话费是%d 余额是%d' 
  print(demo2 % ('tony', 1, -100))

三、基本运算符

1.数学运算符

 # +、-、*、/、%、//、**

2.简化写法

     n = 10
    n += 1  # n = n + 1
    n -= 1  # n = n - 1
    n *= 1  # n = n * 1
    n /= 1  # n = n / 1
    n %= 1  # n = n % 1
    n //= 1  # n = n // 1
    n **= 1  # n = n ** 1

3.比较运算符

 <、>、<=、>=、==(等于号)、!=(不等于号)

四、常用赋值赋

1.链式赋值

    name = 'jason'
   name1 = name
   name2 = name
  则链式赋值可以改写成：
   name = name1 = name2 ='jason'

2.交叉赋值

 m = 100
   n = 999
  #如何让m和n互相交换绑定的数据值
   1）方法一：采用中间变量 做中介
    temp = m
    m = n
    n = temp
    print(m, n)  # 999 100
   2）方法二：交叉赋值语法 直接交换 
    m, n = n, m
    print(m, n)  # 999 100即交换成功

3.解压赋值```python

  name_list = ['jason', 'sam', 'amy', 'jack']
  
  #赋值语法
    name1, name2, name3, name4 = name_list
    '解压赋值在使用的时候，正常情况下需要保证左边的变量名和右边的数据值个数一致'
   a, b = name_list  # 变量名少了不行
   a, b, c, d, e = name_list  # 变量名多了也不行
    
    '当需要解压的数据个数特别多我们只需要使用其中几个的时候，那么可以打破上述的规则'
    a, *b = name_list  # *会自动接收多余的数据 组织成列表赋值给后面的变量名
    print(a)  # jason
    print(b)  # ['kevin', 'tony', 'oscar']

五、逻辑运算符

 1.and 与
  and连接的多个条件必须全部成立，结果才能通过成立
    1 > 2 and 4 < 8 and 10 < 1 and 1 == 2  
  如果条件中全部由and组成那么判断起来非常的简单 只要发现一个不成立 结果就不成立 
  
 2.or 或
  or连接的多个条件只要有一个成立，结果就成立
  
    #举例
  1 > 2 and 4 < 8 and 10 < 1 and 1 == 2   
  如果条件中全部由or组成那么判断起来非常的简单，只要发现一个成立，结果就成立
  
  3.not 非
	取反
	类似于说反话

六、成员运算符

  1）列表中
name_list = ['jason', 'kevin', 'oscar', 'jerry']
print('tony' in name_list)  # False
print('tony' not in name_list)  # True
print('j' in name_list)  # False 列表最小单位是数据值  不能再细分
 2）字符串中
s1 = 'hello world'
print('d' in s1)  # 字符串最小单位是单个单个的字符
 3）字典中
d1 =  {
  'username':'jason', 
       'pwd':123
}
print('jason' in d1)  # False 字典成员运算只有键参与
print('username' in d1)  # True

七、身份运算符

 is 用于判断内存地址是否相同
== 判断数据值是否相同
'''
id() 返回一串数字，该数字可以看作是内存的地址
'''

八、基本数据类型

1.整型int

 #整型int，即为整数
 如：age = 18

2.浮点型float

 #浮点型float，即为小数
 如：weight = 66.6

3.字符串str

 #字符串string，即为文本类型的数据值，一般用'' ""引号来创建字符串
 如：name = 'qiuqiu'

4.列表list

 #列表list，使用[ ]表达，多个值之间用逗号隔开，不限制数据类型
# 语法：列表名=[值1，值2]
 如：l1 = [11, 11.11, 'jason',[11, 22]]

5.字典dict

 # 以“键值对”的形式存放数据，key不能重复
能够非常精确的存储和表达数据值的含义
info_dict = {
        'username': 'jason', 
        'age': 18, 
        'hobby': 'read', 
	}
1.字典文字描述 [key:value]
2.按Key取值
#字典只能按K取值 因为字典是无序的 没有索引的概念

6.布尔值bool

 1.布尔值表示两个值之一 True or False
2.只有两种状态
  True  对的 
  False 错的 
3.python中所有的数据都自带布尔值
  布尔值为 False的数据有： False 0 None '' [] {} ()
4.存储布尔值的变量名一般推荐使用is开头
 is_delete = False
 is_alive = True

7.元组tuple

  # '不可变'的列表
 t1 = (11, 22, 33)
 print(t1[0])
 t1[0] = 999
 print(t1)  # 则会报错：TypeError: 'tuple' object does not support item assignment

8.集合set

 # 集合只能用于去重和关系运算
s1 = {1, 2, 3, 4, 5, 6}
set()	定义空集合

九、垃圾回收机制

 1.引用计数
	一个数据被引用时，其引用计数则会+1，而当其引用次数变为0时，将会把这个数据值当作垃圾删除掉。
2.标记清除   ==>解决循环引用占用内存
	当内存占用达到临界值的时候，程序会自动扫描程序中所有的数据，并给只产生循环引用的数据打上标记之后一次性清除。
3.分代回收   ==>频繁更新引用计数会降低运行效率损，耗各项资源

十、流程控制

1.while循环

 只要条件为真，while 就会一直重复执行那段代码块
 
1.while条件中的关键字
break 强行结束循环体
continue 直接跳到条件判断处
2.while else语句
else:
循环体代码没有被强制结束的情况下 执行完毕就会执行else子代码
3.嵌套及全局标志位
  1）break的说明：
	一个break只能结束它所在的那一层循环，有几个while的嵌套，就应该写几个break
	2）标志位
  如果不想反复写break 可以使用全局标志位，在我们需要结束循环的时候，可以改变标志的布尔值，从而结束循环。

2.for循环

 for 变量名 in 待遍历的数据:
for循环体代码
1.for循环使用的主要场景为: 循环获取存储多个数据的数据内部数据值
2.for循环的特点
	1）擅长遍历取值
	2）不需要结束条件，遍历完可以自动结束循环
3.循环主要遍历的数据类型
	1）数据类型有：字符串、列表、元组、字典、集合
	2）应用特点：
（1）字符串：循环遍历的是单个的字符串
（2）字典：循环遍历的是各个键
4.break、 continue 、 else
  break ：for循环体代码中如果执行到break也会直接结束整个for循环
	continue ：for循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
  else ：for循环体代码(没有被break强制结束的情况下)运行完毕之后运行else的代码

十一、数据类型内置方法

1.整型int

 int(+其他数据类型)将其他数据类型转换成 整型int
# int可以将纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
 
二进制 bin
八进制 oct 
十六进制 hex

2.浮点型float

 float(+其类型的数据)
字符串里面可以允许出现一个小数点 其他都必须是纯数字

3.字符串str

 str(+其类型的数据)
可以转换任何类型的数据（只要在前后加引号即可）
 
1.索引取值str[值1]
	s1 = 	'hello world'
	print(s1[0])  # h
2.切片操作str[值1:值2]
	str[值1:值2] 从 索引1 一直到索引 值2到前一位
	print(s1[1:5])  # 顾头不顾尾，从索引1一直切取到索引4
3.修改切片方向（间隔/步长）
	str[值1:值2:值3]  # 从索引1一直到索引2，每次到步长为值3
	print(s1[:])  # 不写数字就默认都要
	print(s1[2:])  # 从索引2开始往后都要
4.统计字符串中字符的个数len
	print(len(s1))
5.移除字符串首位指定字符.strip()
	1）括号内不指定字符串时，默认移除首尾的空格不能移除字符串中间的同样字符
	2）移除指定字符，可指定首部或尾部
	首部  变量名.lstrip()
	尾部  变量名.rstrip()
6.切割字符串中指定的字符 .split()
	1）该方法处理的结果是一个列表
	2）可以从左往右，或者从右往左选择切割个数
  从右往左加r为 .rsplit()
	从左往右，    .split()本身就是从左往右切割
7.字符串格式化输出.format()
	1）format等价于占位符
	2）format索引取索引值
	# {}中+索引值
res = 'rng has {0} tes has {1} edg has {2}'.format('breath','jackeylove','meiko')
 
	3）format直接索引变量名
	# {}中+变量名
res = 'rng has {rng} tes has {tes} edg has {edg}'.format(rng='breath',tes='jackeylove',edg='meiko')
 
	4）format索引变量名 f+'字符串'用法
	# 当变量名为动态时候，format占位 的 变量名 也会随之改变，比占位符号好用
  
8.其他方法 
  1）转换大小写upper与lower
  2）判断字符串中是否是纯数字.isdigit()
  # isdigit 的判断结果是布尔值
  3）替换字符串中指定的内容.replace()
  # 语句
  .replace(被代替的字符, 代替的字符, 替换个数)
  4）字符串的拼接+ 或者 * 或者.join()
    （1）str1 + str2 + str3
      # 多个字符串凭借可以直接相加
  	（2）str * 数字n 直接输出n遍 str
		（3）.join()语句
			# 字符串1+.join([str1,str2,...,strn])，将列表[]中的字符串，用字符串拼接起来
  5）统计指定字符出现的次数.count()
   字符串.count('字符')，统计该字符在字符串中出现的次数
	6）判断字符串的开头或者结尾.startswith()和.endswith()
     字符串.startswith/.endswith ('需要判断的某一个或多个字符')
其得到的结果是布尔值 True/False
	7）.title()  # 将字符串中的每个单词的首字母大写
	8）.capitalize()  # 将第一个单词的首字母大写
	9）.swapcase()  # 将字母的大小写反转
  10）.index()  # 查找字符，找不到直接报错
	11）.find()  # 查找字符，找不到会返回-1

4.列表list

 list(+要转换的数据类型)
# 能够被for循环的数据类型都可以转换成列表：字符串、字典、元组、集合
 
1.索引取值(正负数) 同字符串
	列表的变量名+[索引值]
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1[0]
 
2.切片操作 同字符串
	列表的变量名+[索引值1:索引值2]  # 左包含右不包含
l1[0:4]
 
3.间隔数 同字符串
  列表的变量名+[索引值1:索引值2：步长]
l1[::-2]  # 步长为负值，表示方向从右往左
 
4.统计列表中数据值的个数长度len()
len(l1)
 
5.数据值修改
列表变量名[索引值] = 要修改的值
l1[0] = 123  # 将索引0 修改成123
 
6.列表添加数据值.append()/.insert()/.extend()
 1）尾部追加数据值 .append()
l1.append(123) 
 
 2）任意位置插入数据值 .insert()
列表名.insert(索引值,要插入该索引值的数据值)
l1.insert(0, 11111)  # 将索引0插入 数据11111
 
 3）扩展列表 合并列表 .extend()
# 语句
列表1+.extend(列表2)
print(ll1 + ll2)  # [11, 22, 33, 44, 55, 66]
ll1.extend(ll2)  # extend相当于 for循环+append
print(ll1)  
------------------
[11, 22, 33, 44, 55, 66]
 
7.删除列表数据
 1）通用的删除关键字 del
 del +列表[索引值]
 del l1[0]
 
 2）删除括号内的数据值 .remove()
 列表名.remove(要删除的数据值)
l1.remove('uZi')  # 如果删除的是字符串，大小写要一致
 
 3）括号内填写索引值 .pop() 
 列表名.pop(要删除的索引值)
l1.pop(1)  # 删除索引值1 的数据值
 
8.排序.sort()
列表名+.sort() # 默认是升序
9.统计列表中某个数据值出现的次数.count()
列表名+.count(要统计的数据值)
10.颠倒列表顺序.reverse()
列表名+.reverse

5.字典dict

 1.按key取值
字典名['k值']
2.按内置方法get取值
字典+ .get('要取的values的keys')
字典+ .get('要取的values','当不存在对应的keys时返回这串字符')
3.修改数据值
字典['要改变values的keys'] = '要改变的values'
当要改变的键存在  # 会直接改变这个键的数据值
4.新增键值对
字典['要增加的keys'] = '要增加的values'  # 会直接在字典末尾增添新的键值对
5.删除数据del 、pop
 1） del +字典['要删除的keys']
 2） 字典.pop('要弹出的keys')
 3） popitem() 用来随机删除一个键值对
6.统计字典中键值对的个数 len()
7.字典三剑客
 1） 字典.keys()  # 一次性获取字典所有的键
 2） 字典.values()  # 一次性获取字典所有的值
 3） 字典.items()   # 一次性获取字典的键值对数据
 
8.其他
 1） .fromkeys 生成相同数据值不同键的字典
  dict.fromkeys(['要生成的列表的keys'], 要生成的数据值values)
  
 2） append 为数据值为空列表的时候添加数据值
 3） detdefault 默认值 None

6.元组tuple

 tuple() 支持for循环的数据类型都可以转换为元组
 
1.索引取值、切片间隔
	1）索引取值
	元组[索引值]
	# 其中 索引值可以是正数也可以是负数 ，负数代表了方向从右往左
	2）切片间隔
	元组[起始索引:结束索引:步长step]
  
2.统计元组内数据值的个数len
3.统计元组内某个数据值出现的次数count
4.统计元组内制定数据值的索引值index
  index访问元组中的某个元素,得到的是这个元素的索引值
5.关于元组的注意要点
  1）元组内如果只要一个数据值那么逗号不能少
  2）元组内索引绑定的内存地址不能被修改（注意区分 可变与不可变）
  3）元组内不能新增或者删除数据

7.集合set

 set() 集合常常应于 去重和关系运算
# 集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
#	集合内数据也是无序的,没有索引的概念
 
1.去重
 print直接打印就是去重
2.关系运算
l1 = {'jason', 'tony', 'jerry', 'oscar'}
l2 = {'jack', 'jason', 'tom', 'tony'}
求两个人的共同好友
print(l1 & l2)
求用于1独有的好友
print(l1 - l2)
求两个人所有的好友
print(l1 | l2)
求两个人独有的好友
print(l1 ^ l2)
交集	&	取两集合公共的元素	set1 & set2 
并集	|	取两集合全部的元素	set1 | set2 
差集	-	取一个集合中另一集合没有的元素	set1 - set2 
对称差集	^ 取集合 A 和 B 中不属于 A&B 的元素	set1 ^ set2

十二、可变类型和不可变类型

   # 字符串在调用内置方法之后并不会修改自己，而是产生一个新的结果
  # 列表在调用内置方法以后修改的就是自身，并没有产生一个新的结果
如何查看调用方法有没有新的结果，可以在调用该方法的代码左侧添加变量名和赋值符号
1.可变类型：数据值改变，内存地址不变：
    列表，字典、集合
2.不可变类型：数据值改变，内存地址肯定变：
    字符串

十三、字符编码理论

 # unicode万国码
       兼容所有国家语言字符，起步就是两个字节来表示字符 
# utf系列:utf8 utf16 ...
       专门用于优化unocide存储问题，英文还是采用一个字节，中文三个字节
1.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        # 字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        # bytes类型数据.decode()

posted @ 2022-10-07 20:37 Duosg 阅读(36) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 数据类型内置方法上：整型、浮点型、字符串、列表

· python之基本数据类型

· python基础知识回顾

· 10.3学习归纳总结

· python续集

阅读排行：
· Blazor Hybrid适配到HarmonyOS系统
· Obsidian + DeepSeek：免费 AI 助力你的知识管理，让你的笔记飞起来！
· 解决跨域问题的这6种方案，真香！
· 一套基于 Material Design 规范实现的 Blazor 和 Razor 通用组件库
· 数据并发安全校验处理工具类

公告

昵称： Duosg
园龄： 2年5个月
粉丝： 11
关注： 21

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

阅读排行榜

评论排行榜

1. 十二周周末小结结(1)

	input
	# 获取用户输入
	username = input('请输入您的用户名>>>:')

	print()
	1）括号内既可以放数据值，也可以放变量名，并且支持多个数据值或者变量名，用逗号隔开即可
	2） print 自带换行符
	# 换行符：\r\n 或者\n（斜杠与字母组合可能会产生特殊含义）
	3） print也可以切换结束符
	print(数据，end='默认是\n')

	1.代码实现
	在现实生活中大部分情况下使用下划线提示别人填写内容
	但是在程序中需要使用占位符:%s %d
	2.不同占位符的区别
	# %s常见数据类型都支持
	demo1 = '%s您好您本月的话费是%s 余额是%s'
	print(demo1 % ('jason', 100, 1))
	# %d只支持数字类型
	demo2 = '%d您好您本月的话费是%d 余额是%d'
	print(demo2 % ('tony', 1, -100))

	n = 10
	n += 1 # n = n + 1
	n -= 1 # n = n - 1
	n = 1 # n = n 1
	n /= 1 # n = n / 1
	n %= 1 # n = n % 1
	n //= 1 # n = n // 1
	n = 1 # n = n 1

	name = 'jason'
	name1 = name
	name2 = name
	则链式赋值可以改写成：
	name = name1 = name2 ='jason'

	m = 100
	n = 999
	#如何让m和n互相交换绑定的数据值
	1）方法一：采用中间变量做中介
	temp = m
	m = n
	n = temp
	print(m, n) # 999 100
	2）方法二：交叉赋值语法直接交换
	m, n = n, m
	print(m, n) # 999 100即交换成功

	name_list = ['jason', 'sam', 'amy', 'jack']

	#赋值语法
	name1, name2, name3, name4 = name_list
	'解压赋值在使用的时候，正常情况下需要保证左边的变量名和右边的数据值个数一致'
	a, b = name_list # 变量名少了不行
	a, b, c, d, e = name_list # 变量名多了也不行

	'当需要解压的数据个数特别多我们只需要使用其中几个的时候，那么可以打破上述的规则'
	a, b = name_list # 会自动接收多余的数据组织成列表赋值给后面的变量名
	print(a) # jason
	print(b) # ['kevin', 'tony', 'oscar']

	1.and 与
	and连接的多个条件必须全部成立，结果才能通过成立
	1 > 2 and 4 < 8 and 10 < 1 and 1 == 2
	如果条件中全部由and组成那么判断起来非常的简单只要发现一个不成立结果就不成立

	2.or 或
	or连接的多个条件只要有一个成立，结果就成立

	#举例
	1 > 2 and 4 < 8 and 10 < 1 and 1 == 2
	如果条件中全部由or组成那么判断起来非常的简单，只要发现一个成立，结果就成立

	3.not 非
	取反
	类似于说反话

	1）列表中
	name_list = ['jason', 'kevin', 'oscar', 'jerry']
	print('tony' in name_list) # False
	print('tony' not in name_list) # True
	print('j' in name_list) # False 列表最小单位是数据值不能再细分
	2）字符串中
	s1 = 'hello world'
	print('d' in s1) # 字符串最小单位是单个单个的字符
	3）字典中
	d1 = {
	'username':'jason',
	'pwd':123
	}
	print('jason' in d1) # False 字典成员运算只有键参与
	print('username' in d1) # True

	is 用于判断内存地址是否相同
	== 判断数据值是否相同
	'''
	id() 返回一串数字，该数字可以看作是内存的地址
	'''

	float(+其类型的数据)
	字符串里面可以允许出现一个小数点其他都必须是纯数字

	#字符串string，即为文本类型的数据值，一般用'' ""引号来创建字符串
	如：name = 'qiuqiu'

	#列表list，使用[ ]表达，多个值之间用逗号隔开，不限制数据类型
	# 语法：列表名=[值1，值2]
	如：l1 = [11, 11.11, 'jason',[11, 22]]

	# 以“键值对”的形式存放数据，key不能重复
	能够非常精确的存储和表达数据值的含义
	info_dict = {
	'username': 'jason',
	'age': 18,
	'hobby': 'read',
	}
	1.字典文字描述 [key:value]
	2.按Key取值
	#字典只能按K取值因为字典是无序的没有索引的概念

	1.布尔值表示两个值之一 True or False
	2.只有两种状态
	True 对的
	False 错的
	3.python中所有的数据都自带布尔值
	布尔值为 False的数据有： False 0 None '' [] {} ()
	4.存储布尔值的变量名一般推荐使用is开头
	is_delete = False
	is_alive = True

	# '不可变'的列表
	t1 = (11, 22, 33)
	print(t1[0])
	t1[0] = 999
	print(t1) # 则会报错：TypeError: 'tuple' object does not support item assignment

	# 集合只能用于去重和关系运算
	s1 = {1, 2, 3, 4, 5, 6}
	set() 定义空集合

	1.引用计数
	一个数据被引用时，其引用计数则会+1，而当其引用次数变为0时，将会把这个数据值当作垃圾删除掉。
	2.标记清除 ==>解决循环引用占用内存
	当内存占用达到临界值的时候，程序会自动扫描程序中所有的数据，并给只产生循环引用的数据打上标记之后一次性清除。
	3.分代回收 ==>频繁更新引用计数会降低运行效率损，耗各项资源

	只要条件为真，while 就会一直重复执行那段代码块

	1.while条件中的关键字
	break 强行结束循环体
	continue 直接跳到条件判断处
	2.while else语句
	else:
	循环体代码没有被强制结束的情况下执行完毕就会执行else子代码
	3.嵌套及全局标志位
	1）break的说明：
	一个break只能结束它所在的那一层循环，有几个while的嵌套，就应该写几个break
	2）标志位
	如果不想反复写break 可以使用全局标志位，在我们需要结束循环的时候，可以改变标志的布尔值，从而结束循环。

	for 变量名 in 待遍历的数据:
	for循环体代码
	1.for循环使用的主要场景为: 循环获取存储多个数据的数据内部数据值
	2.for循环的特点
	1）擅长遍历取值
	2）不需要结束条件，遍历完可以自动结束循环
	3.循环主要遍历的数据类型
	1）数据类型有：字符串、列表、元组、字典、集合
	2）应用特点：
	（1）字符串：循环遍历的是单个的字符串
	（2）字典：循环遍历的是各个键
	4.break、 continue 、 else
	break ：for循环体代码中如果执行到break也会直接结束整个for循环
	continue ：for循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
	else ：for循环体代码(没有被break强制结束的情况下)运行完毕之后运行else的代码

	int(+其他数据类型)将其他数据类型转换成整型int
	# int可以将纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错

	二进制 bin
	八进制 oct
	十六进制 hex

duoduosg

python基础之周末小结

一、与用户交互

1.获取用户输入

2.输出内部信息

二、格式化输出

三、基本运算符

1.数学运算符

2.简化写法

3.比较运算符

四、常用赋值赋

1.链式赋值

2.交叉赋值

3.解压赋值```python

五、逻辑运算符

六、成员运算符

七、身份运算符

八、基本数据类型

1.整型int

2.浮点型float

3.字符串str

4.列表list

5.字典dict

6.布尔值bool

7.元组tuple

8.集合set

九、垃圾回收机制

十、流程控制

1.while循环

2.for循环

十一、数据类型内置方法

1.整型int

2.浮点型float

3.字符串str

4.列表list

5.字典dict

6.元组tuple

7.集合set

十二、可变类型和不可变类型

十三、字符编码理论

公告

搜索

常用链接

我的标签

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	str(+其类型的数据)
	可以转换任何类型的数据（只要在前后加引号即可）

	1.索引取值str[值1]
	s1 = 'hello world'
	print(s1[0]) # h
	2.切片操作str[值1:值2]
	str[值1:值2] 从索引1 一直到索引值2到前一位
	print(s1[1:5]) # 顾头不顾尾，从索引1一直切取到索引4
	3.修改切片方向（间隔/步长）
	str[值1:值2:值3] # 从索引1一直到索引2，每次到步长为值3
	print(s1[:]) # 不写数字就默认都要
	print(s1[2:]) # 从索引2开始往后都要
	4.统计字符串中字符的个数len
	print(len(s1))
	5.移除字符串首位指定字符.strip()
	1）括号内不指定字符串时，默认移除首尾的空格不能移除字符串中间的同样字符
	2）移除指定字符，可指定首部或尾部
	首部变量名.lstrip()
	尾部变量名.rstrip()
	6.切割字符串中指定的字符 .split()
	1）该方法处理的结果是一个列表
	2）可以从左往右，或者从右往左选择切割个数
	从右往左加r为 .rsplit()
	从左往右， .split()本身就是从左往右切割
	7.字符串格式化输出.format()
	1）format等价于占位符
	2）format索引取索引值
	# {}中+索引值
	res = 'rng has {0} tes has {1} edg has {2}'.format('breath','jackeylove','meiko')

	3）format直接索引变量名
	# {}中+变量名
	res = 'rng has {rng} tes has {tes} edg has {edg}'.format(rng='breath',tes='jackeylove',edg='meiko')

	4）format索引变量名 f+'字符串'用法
	# 当变量名为动态时候，format占位的变量名也会随之改变，比占位符号好用

	8.其他方法
	1）转换大小写upper与lower
	2）判断字符串中是否是纯数字.isdigit()
	# isdigit 的判断结果是布尔值
	3）替换字符串中指定的内容.replace()
	# 语句
	.replace(被代替的字符, 代替的字符, 替换个数)
	4）字符串的拼接+ 或者 * 或者.join()
	（1）str1 + str2 + str3
	# 多个字符串凭借可以直接相加
	（2）str * 数字n 直接输出n遍 str
	（3）.join()语句
	# 字符串1+.join([str1,str2,...,strn])，将列表[]中的字符串，用字符串拼接起来
	5）统计指定字符出现的次数.count()
	字符串.count('字符')，统计该字符在字符串中出现的次数
	6）判断字符串的开头或者结尾.startswith()和.endswith()
	字符串.startswith/.endswith ('需要判断的某一个或多个字符')
	其得到的结果是布尔值 True/False
	7）.title() # 将字符串中的每个单词的首字母大写
	8）.capitalize() # 将第一个单词的首字母大写
	9）.swapcase() # 将字母的大小写反转
	10）.index() # 查找字符，找不到直接报错
	11）.find() # 查找字符，找不到会返回-1

	list(+要转换的数据类型)
	# 能够被for循环的数据类型都可以转换成列表：字符串、字典、元组、集合

	1.索引取值(正负数) 同字符串
	列表的变量名+[索引值]
	l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
	l1[0]

	2.切片操作同字符串
	列表的变量名+[索引值1:索引值2] # 左包含右不包含
	l1[0:4]

	3.间隔数同字符串
	列表的变量名+[索引值1:索引值2：步长]
	l1[::-2] # 步长为负值，表示方向从右往左

	4.统计列表中数据值的个数长度len()
	len(l1)

	5.数据值修改
	列表变量名[索引值] = 要修改的值
	l1[0] = 123 # 将索引0 修改成123

	6.列表添加数据值.append()/.insert()/.extend()
	1）尾部追加数据值 .append()
	l1.append(123)

	2）任意位置插入数据值 .insert()
	列表名.insert(索引值,要插入该索引值的数据值)
	l1.insert(0, 11111) # 将索引0插入数据11111

	3）扩展列表合并列表 .extend()
	# 语句
	列表1+.extend(列表2)
	print(ll1 + ll2) # [11, 22, 33, 44, 55, 66]
	ll1.extend(ll2) # extend相当于 for循环+append
	print(ll1)
	------------------
	[11, 22, 33, 44, 55, 66]

	7.删除列表数据
	1）通用的删除关键字 del
	del +列表[索引值]
	del l1[0]

	2）删除括号内的数据值 .remove()
	列表名.remove(要删除的数据值)
	l1.remove('uZi') # 如果删除的是字符串，大小写要一致

	3）括号内填写索引值 .pop()
	列表名.pop(要删除的索引值)
	l1.pop(1) # 删除索引值1 的数据值

	8.排序.sort()
	列表名+.sort() # 默认是升序
	9.统计列表中某个数据值出现的次数.count()
	列表名+.count(要统计的数据值)
	10.颠倒列表顺序.reverse()
	列表名+.reverse

	1.按key取值
	字典名['k值']
	2.按内置方法get取值
	字典+ .get('要取的values的keys')
	字典+ .get('要取的values','当不存在对应的keys时返回这串字符')
	3.修改数据值
	字典['要改变values的keys'] = '要改变的values'
	当要改变的键存在 # 会直接改变这个键的数据值
	4.新增键值对
	字典['要增加的keys'] = '要增加的values' # 会直接在字典末尾增添新的键值对
	5.删除数据del 、pop
	1） del +字典['要删除的keys']
	2）字典.pop('要弹出的keys')
	3） popitem() 用来随机删除一个键值对
	6.统计字典中键值对的个数 len()
	7.字典三剑客
	1）字典.keys() # 一次性获取字典所有的键
	2）字典.values() # 一次性获取字典所有的值
	3）字典.items() # 一次性获取字典的键值对数据

	8.其他
	1） .fromkeys 生成相同数据值不同键的字典
	dict.fromkeys(['要生成的列表的keys'], 要生成的数据值values)

	2） append 为数据值为空列表的时候添加数据值
	3） detdefault 默认值 None

	tuple() 支持for循环的数据类型都可以转换为元组

	1.索引取值、切片间隔
	1）索引取值
	元组[索引值]
	# 其中索引值可以是正数也可以是负数，负数代表了方向从右往左
	2）切片间隔
	元组[起始索引:结束索引:步长step]

	2.统计元组内数据值的个数len
	3.统计元组内某个数据值出现的次数count
	4.统计元组内制定数据值的索引值index
	index访问元组中的某个元素,得到的是这个元素的索引值
	5.关于元组的注意要点
	1）元组内如果只要一个数据值那么逗号不能少
	2）元组内索引绑定的内存地址不能被修改（注意区分可变与不可变）
	3）元组内不能新增或者删除数据

	set() 集合常常应于去重和关系运算
	# 集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
	# 集合内数据也是无序的,没有索引的概念

	1.去重
	print直接打印就是去重
	2.关系运算
	l1 = {'jason', 'tony', 'jerry', 'oscar'}
	l2 = {'jack', 'jason', 'tom', 'tony'}
	求两个人的共同好友
	print(l1 & l2)
	求用于1独有的好友
	print(l1 - l2)
	求两个人所有的好友
	print(l1 \| l2)
	求两个人独有的好友
	print(l1 ^ l2)
	交集 & 取两集合公共的元素 set1 & set2
	并集 \| 取两集合全部的元素 set1 \| set2
	差集 - 取一个集合中另一集合没有的元素 set1 - set2
	对称差集 ^ 取集合 A 和 B 中不属于 A&B 的元素 set1 ^ set2

	# 字符串在调用内置方法之后并不会修改自己，而是产生一个新的结果
	# 列表在调用内置方法以后修改的就是自身，并没有产生一个新的结果
	如何查看调用方法有没有新的结果，可以在调用该方法的代码左侧添加变量名和赋值符号
	1.可变类型：数据值改变，内存地址不变：
	列表，字典、集合
	2.不可变类型：数据值改变，内存地址肯定变：
	字符串

	# unicode万国码
	兼容所有国家语言字符，起步就是两个字节来表示字符
	# utf系列:utf8 utf16 ...
	专门用于优化unocide存储问题，英文还是采用一个字节，中文三个字节
	1.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
	# 字符串.encode()
	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
	# bytes类型数据.decode()