亲爱的读者们,今天我们要讨论,python中3//2的值为1.5 python3中3/2的结果,一起探索吧!
本篇文章给大家谈谈python3中3/2的结果,以及python中3>2>1的值,希望对各位有所帮助,不要忘了收藏本站喔python技术开发高级证书。
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 = ""
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x000001A70E7D0A60>
>>> sio.getvalue()
''
>>> (7)
7
>>> sio.write('a')
1
>>> sio.getvalue()
''
其他的方法:
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()
集合的相关操作
原文地址1:https://blog.csdn.net/S1112_/article/details/135041116
参考资料:python中用turtle画一个圆形 https://blog.csdn.net/SXIAOYAN_/article/details/140061099