本篇文章给大家谈谈python3中3/2的结果，以及python中3>2>1的值，希望对各位有所帮助，不要忘了收藏本站喔。
Python学习
文章目录
- Python学习
- 一.字符串操作详解
- 二.关系运算符和运算操作
- 三.其他序列：
- 3.1列表
- 3.2元组
- 3.3字典
- 3.4集合
一.字符串操作详解
1.字符串正向搜索： 最左侧第一个下标（偏移量）是0；
反向搜索：最右侧第一个字符，偏移量是（-1）
2.replace()： 字符串的替换
>>> a = "adasdasd"
>>> b = a.replace('a','e')
>>> b
'edesdesd'
>>> a
'adasdasd'Tip： 替换并不是在原有的字符串上直接进行修改的，而是替换之后生成了一个新的字符串
3.字符串切片 slice 操作：
a = “abcdefg”;
a[起始偏移量start：终止偏移量end：步长step]
a[1,5,1] = ‘bcde’ //不能到五，左闭右开
a[1,5,2] = ‘bd’ //每隔一个取一个
>>> a = "adasdasdasd"
>>> a[-3:]
'asd'
>>> a[-8:-3]
'sdasd'
>>> a
'adasdasdasd'
>>> a[::-1]
'dsadsadsada'例题：
①将”to be or not to be”字符串倒序输出
>>> a = "to be or not to be"
>>> a[::-1]
'eb ot ton ro eb ot'②将”sxtsxtsxtsxtsxt”字符串中所有的s和t输出
>>> b = "sxtsxtsxtsxtsxt"
>>> b[::-3]
'ttttt'
>>> b[::3]
'sssss'4.split（）分割和join（）合并:
split(): 可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)python练手怎么接单。示例代码如下:
>>> a = "to be or not to be"
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split('be')
['to ', ' or not to ', '']join(): 作用是和split()方法的作用相反，实例：
>>> a = ['et','asa','sasa']
>>> '*'.join(a)
'et*asa*sasa'join()和拼接符’+'效率的差距：
字符串驻留机制：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。Python支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线(_)、字母和数字）会启用字符串驻留机制驻留机制。
>>> a = "adb_33"
>>> b = "adb_33"
>>> a is b
True
>>> c = "dd#"
>>> d = "dd#"
>>> c is d
False字符串比较：
a = “abc”;
“b” in a --> true
“d” not in a-->true字符格式：从某方向以某格式以某字符补齐
>>> #使用ceneter()、ljust()、rjust()这三个函数用于对字符创实现排版。实例如下()
>>> a.center(10,"*")
'***SXT****'
>>> a.center(10)
' SXT '
>>> a.ljust(10,"*")
'SXT*******'
>>> a.rjust(10,"*")
'*******SXT'字符查找方法：
len()： 返回字符串的长度
startswith(): 以指定的字符串开头
endswith(0: 以指定的字符串结尾
find(): 第一次出现指定字符串的位置
rfind(): 最后一次出现字符串的位置
count(): 指定字符串出现了几次
isalnum(): 所有的字符全是数字或者是字母
>>> a = "sfjkllahjhjfkl"
>>> len(a)
14
>>> a.startswith("sf")
True
>>> a.endswith("kl")
True
>>> a.find('a')
6
>>> a.rfind('l')
13
>>> a.isalnum()
True
>>> a.count('l')
3大小写转换
capitalize(): 产生新的字符串,首字母大写
title(): 产生新的字符串，每个单词都首字母大写
upper(): 产生新的字符串，所有的字符串全都转换成大写
lower(): 产生新的字符串，所有的字符串转成小写
swapcase(): 产生新的字符串，左右的字母大小写颠倒
>>> b = "das dass dddd"
>>> b.capitalize()
'Das dass dddd'
>>> b.title()
'Das Dass Dddd'
>>> b.upper()
'DAS DASS DDDD'
>>> b.lower()
'das dass dddd'
>>> c = "adsAAAb"
>>> d = c.swapcase()
>>> d
'ADSaaaB'
>>> c
'adsAAAb'format() 基本用法
（Python2.6开始）基本语法： 通过{} 和：来代替以前的%，实例：
>>> a = "名字是：{0}，年龄是{1}"
>>> a.format('da',3)
'名字是：da，年龄是3'填充和补齐：
填充和补齐常常一起使用
^、<、>分别是居中、左对齐、右对齐 后面带宽度
： 号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
>>> a = "{:*>8}"
>>> a.format("13")
'******13'可变字符串
在Python中字符串属于不可变的对象，不支持原地修改，如果需要修改其中的值。只能创建新的字符串对象，但是我们确实需要经常原地修改字符串，可以使用io.StringIO对象或者使用array模块，示例：
>>> import io
>>> s = "hello.sxt"
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x000001A70E7D0A60>
>>> sio.getvalue()
'hello.sxt'
>>> sio.seek(7)
7
>>> sio.write('a')
1
>>> sio.getvalue()
'hello.sat'其他的方法：
isalnum() ： 是否为字母或者数字
isalpha(): 检测字符是否只有字母组成（含汉字）
isdigit()： 检测字符是否只有数字组成
isspace(): 检测字符是否为空白符
issuper(): 是否为大写的字母
islower(): 是否为小写的字母
二.关系运算符和运算操作
关系运算符可以连用：
C++： a>=2&&a<=5
Python: 2<=a<=5
Tip：
①Python中不支持自增自减
②位运算和算术操作>比较运算符>赋值运算符
③在复杂的运算中要用小括号组织
三.其他序列：
3.1列表
列表是内置的可变序列，是包含多个元素的有序连续的内存空间。列表中的元素可以使任意的类型的。
列表的创建：
基本创建：a = [] #创建一个空的列表对象
list() 创建：
>>>a = list()
>>>a
[]
>>>a = list(range(10))
>>>a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a = list(‘s’)
>>>a
[‘a’]
Tip: range() ： 创造的不是一个列表，是一个class<range>,若要转换成list，请看下面的示例：
>>> a = range(0,10)
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b = list(a)
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a
range(0, 10)以下是列表的常用方法：
insert(): 插入元素 但是在有大量元素时不建议使用，因为这样子会让这个位置后面的所有元素往后移动
append(): 增加元素 参数是普通元素
extend(): 增加元素 参数是列表
insert(index,x)： 增加元素 在index位置添加元素x
remove(x): 删除首次出现的元素
pop(x)： 删除并返回列表中指定为x的元素，默认是删除最后一个元素
clear(): 删除所有的元素
>>> a = [12,13,'a',42]
>>> b = ['1']
>>> a.append('ad')
>>> a
[12, 13, 'a', 42, 'ad']
>>> a.extend(b)
>>> a
[12, 13, 'a', 42, 'ad', '1']
>>> a.insert(2,'as')
>>> a
[12, 13, 'as', 'a', 42, 'ad', '1']
>>> a.remove(12)
>>> a
[13, 'as', 'a', 42, 'ad', '1']
>>> c = a.pop()
>>> a
[13, 'as', 'a', 42, 'ad']
>>> c
'1'
>>> a.clear()
>>> a
[]以下是其他的方法：
reverse(): 翻转列表
sort(): 所有的元素原地排序
copy(): 返回列表对象的浅拷贝
del()：删除指定位置的元素
index(): 获取指定元素在列表中首次出现的索引
count()： 获得元素在列表中的出现次数
len()： 返回列表长度
max(): 返回列表中元素的最大值
min(): 返回列表中元素的最小值
sum(): 对数值型的列表进行求和操作，其他类型会报错
>>> a = [1,2,2]
>>> a.insert(1,2)
>>> a
[1, 2, 2, 2]
>>> a = [123,131,3211,11]
>>> a.sort()
>>> a
[11, 123, 131, 3211]
>>> a.reverse()
>>> a
[3211, 131, 123, 11]
>>> a.copy()
[3211, 131, 123, 11]
>>> b = a.copy()
>>> b
[3211, 131, 123, 11]列表切片操作
Tip:贴片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会被当做0，终止偏移量大于“长度1”会被当成-1： 例如：
列表的排序
①不创建新的列表的排序 内置函数（sorted()）
>>> b = [1,23,133,0]
>>> b.sort() #默认是升序排列
>>> b
[0, 1, 23, 133]
>>> b.sort(reverse = True) #降序排列
>>> b
[133, 23, 1, 0]②打乱顺序
>>> a = [12,222,1]
>>> import random
>>> random.shuffle(a)
>>> a
[222, 12, 1]③创建新的列表的排序 内置函数（sorted）
>>> b = [1,22,33,0]
>>> sorted(b)
[0, 1, 22, 33]
>>> b
[1, 22, 33, 0]
>>> c = sorted(b)
>>> c
[0, 1, 22, 33]④逆序排序
方式一.切片操作
>>> c = [321,43,4,0]
>>> c[::-1]
[0, 4, 43, 321]方式二.迭代器
多维列表
一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表的数据。例如下面的数据：
我们可以这样子来存储：
代码示例：
>>> a = [["甲",1223,'dadsda'],
["乙",12323,'dadqwdsda'],
["丙",122323,'dadsd312312a']]
>>> a
[['甲', 1223, 'dadsda'], ['乙', 12323, 'dadqwdsda'], ['丙', 122323, 'dadsd312312a']]二维列表相当于是列表中的列表
二维列表中的元素我们可以通过索引的方式访问
>>> a[1][2]
'dadqwdsda'
>>> a[0][0]
'甲'
>>> a[1]
['乙', 12323, 'dadqwdsda']内存结构：
3.2元组
元组属于不可变序列，不能修改元组中的元素。因此，元组中没有增删改的方法。
元组的访问和计数
索引访问：
>>> a = tuple([1,2,3,4243])
>>> a
(1, 2, 3, 4243)
>>> a[1]
2
>>> a[0]
1切片访问:
>>> a = tuple([1,2,3,4243])
>>> a[1:3]
(2, 3)
>>> a[:4]
(1, 2, 3, 4243)
>>> a[:3]
(1, 2, 3)元组的排序： （内置函数sorted） 生成的是一个列表对象
>>> a = tuple([1,23,3,0])
>>> b = sorted(a)
>>> b #注意是生成的列表
[0, 1, 3, 23]
>>> c = tuple(sorted(a))
>>> c
(0, 1, 3, 23)zip操作： 将多个列表对应位置的元素组合成元组，并返回这个zip对象
元组的生成器推导式
>>> s = (x*2 for x in range(5)) #生成了一个只能使用一次的生成器
>>> s
<generator object <genexpr> at 0x0000022A06C48D60>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> tuple(s) #第二次使用为空 生成器的指针跳出
()指针移动示例
>>> s = (x*2 for x in range(4))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
s.__next__()
StopIteration元组的总结：
①元组的核心特点是： 不可变序列
②元组的访问和处理速度比列表快
③与整数字符串一样，元组可以作为字典的键，列表则永远不能作为字典的关键字使用。
3.3字典
字典概述：字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含︰“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
字典和列表: 列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如∶整数、浮点数、字符串、元组。但是∶列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。“值”可以是任意的数据，并且可以重复
字典的典型定义：
a = {'name':'yyy','age':12,'job':'student'}字典的创建
①我们可以通过{}、dict()来创建字典对象
>>> a = {'name':'yyy','age':12,'job':'student'}
>>> b = dict(name = 'yyy',age = 13,job = 'student')
>>> c = dict([("name",'yyy'),('age',12)])
>>> d = {} #空的字典对象
>>> e = dict() #空的字典对象②通过zip()创建字典对象
>>> k = ['name','age','job'] #键
>>> v = ['yyy',12,'teacher'] #值
>>> d = dict(zip(k,v)) #通过zip来包装
>>> d
{'name': 'yyy', 'age': 12, 'job': 'teacher'}③通过fromkeys创建值为空的字典
>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None} #这里的None是一个值，表示为空字典元素的访问
①通过[键] 获得"值"。若值不存在，则抛出异常。
>>> a = {'name':'yyy','age':12,'job':'student'}
>>> a['name']
'yyy'②通过get方法获得值。推荐使用，因为指定键不存在时，返回的是None；也可以设定指定键不存在时默认返回的对象。
>>> a.get('name')
'yyy'
>>> a.get('adda')
>>> print(a.get('adas'))
None
>>> a.get('sadasda','没')
'没'③列出所有的键值对
>>> a.items()
dict_items([('name', 'yyy'), ('age', 12), ('job', 'student')])④写出所有的键，列出所有的值
>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['yyy', 12, 'student'])⑤len() 键值对的个数
>>> len(a)
3⑥检测一个"键"是否在字典中
>>> 'name' in a
True字典元素的添加修改和删除
①给字典新增键值对，若键已经存在则覆盖旧的，若不存在则添加新的
>>> a['s'] = 123
>>> a
{'name': 'yyy', 'age': 12, 'job': 'student', 's': 123}②使用update() 将字典中的所有键值对全部添加到旧字典对象上。如果key有重复，则直接覆盖
>>> a = {'name':'yyy','age':12,'job':'student'}
>>> b = {'name':'asa','age':1232,'money':12222}
>>> a.update(b)
>>> a
{'name': 'asa', 'age': 1232, 'job': 'student', 'money': 12222}③字典元素的删除，可以使用del()方法；或者clear()删除多有的键值对；pop（）删除所有的键值对并返回指定的键值对对象。
④popitem(): 随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念;popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效(因为不用首先获取键的列表）。
>>> a.popitem()
('money', 12222)
>>> a
{'name': 'asa', 'age': 1232, 'job': 'student'}
>>> a.popitem()
('job', 'student')
>>> a
{'name': 'asa', 'age': 1232}序列解包
可以用于元组、列表、字典。方便我们对多个变量赋值。
>>> x,y,z = 20,10,30 #列表
>>> x
20
>>> a,b,c = (20,30,10) #元组
>>> a
20序列解包用于字典时，默认是对“键”进行操作﹔如果需要对键值对操作，则需要使用items0 ﹔如果需要对“值”进行操作，则需要使用values0 ;
>>> s = {'name ':'aaa','age':12,'class':12}
>>> x,y,z = s
>>> x
'name '
>>> a,b,c = s.values()
>>> a
'aaa'
>>> h,j,k = s.items()
>>> h
('name ', 'aaa')表格数据使用字典和列表存储，并且实现访问
r1 = {'name':'sss','age':12}
r2 = {'name':'ss','age':112}
r3 = {'name':'s','age':1112}
tb = [r1,r2,r3]
#获得第二行人的年龄
print(tb[1].get('age'))
#打印所有的年龄
for x in range(len(tb)):
print(tb[x].get('age'))字典实现的核心底层原理（重要）
字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组），数组的每个单元叫做 bucket。每个bucket有两部分︰一个是键对象的引用，一个是值对象的引用。由于，所有bucket结构和大小一致，我们可以通迁偏移量衷读取指定bucket.
将一个键值对放进字典的底层过程
当数组大小不够时，会自动扩容
根据键查找“键值对”的底层过程
用法总结：
①键必须可散列
a.数字、字符串、元组，都是可散列的
b.自定义对象需要支持hash()函数、支持通过__eq__()方法检测相等性、若a==b为真，则hash(a)==hash(b)也为真。
②字典在内存中的开销巨大，典型的空间换时间
③键查询速度很快
④往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改。
3.4集合
集合是无序可变、元素不能重身。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，囚此是不能重复的且唯一的。
集合创建和删除
①使用{}创建集合对象，并使用add() 方法添加元素
>>> a ={12312,20,3,"dd"}
>>> a
{12312, 3, 20, 'dd'}
>>> a.add("adasd")
>>> a
{'adasd', 3, 20, 12312, 'dd'}②使用set()，将列表、元组等可迭代对象转换成集合。如果原来的数据存在重复数据，则只保留一个。
>>> a = ['a','b',23213]
>>> b = set(a)
>>> b
{'b', 'a', 23213}③remove()删除指定元素；clear()清空整个集合
>>> b.remove('a')
>>> b
{'b', 23213}
>>> b.clear()
>>> b
set()集合的相关操作
