python数字类型及运算_Python基础之（基本数据类型及运算）

一、运算

1.1、算数运算

1.2、比较运算：

1.3、赋值运算：

1.4、逻辑运算：

1.5、成员运算：

针对逻辑运算的进一步研究：

1、在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。

2、 x or y , x为真，值就是x，x为假，值是y；

x and y, x为真，值是y,x为假，值是x。

3、Python运算符优先级，以下表格列出了从最高到最低优先级的所有运算符：

运算符描述

指数 (最高优先级)

~ + -

按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % //

乘，除，取模和取整除

+ -

加法减法

>> <<

右移，左移运算符

位 'AND'

^ |

位运算符

<= < > >=

比较运算符

<> == !=

等于运算符

= %= /= //= -= += *= **=

赋值运算符

is is not

身份运算符

in not in

成员运算符

not and or

逻辑运算符

二、基本数据类型

2.1、数字，int（整型）

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

2.2、布尔值（bool）

True、False

1、0

真、假

2.3、字符串（str）

"hello world"

在Python中,加了引号的字符都被认为是字符串

2.3.1、索引:

a = 'ABCDEFGHIJK'

print(a[1])

print(a[3])

print(a[5])

print(a[7])

执行结果：

2.3.2、切片，切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串

a = 'ABCDEFGHIJK'

print(a[1:3])

print(a[0:5])

print(a[0:]) #默认从开始到最后

print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是取不到

print(a[0:5:2]) #加步长

print(a[5:0:-2]) #反向加步长

执行结果：

2.3.3、字符串常用方法：

最常用的为：join（字符串拼接）\spilt（切割）\find（查找）\strip（去空格）\upper、lower（大小写转换）\encode、decode（编码、解码）

a="abcABC"

#公共方法len(a),type(a)

a.capitalize() #首字母大写

a.upper() #转换大写

a.lower() #转换小写

a.swapcase() #大小写转换

a.casefold() #转换小写

a.title() #转换成标题

a.center(20,"*"）#设置宽度，并居中，20为总长度，*为空白处填充

a.ljust(20,"*") #左边

a.rjust(20,"*") #右边

a.zfill(20) #默认使用0填充，长度20

a.expandtabs() #补tab键

a.count("xx"，star，end) #计数出现次数，star开始位置，end结束位置

a.strip() #去全部空格、换行

a.lstrip("xx") #去除左边 xx

a.lstrip() #去左边空格

a.rstrip() #去右边空格

a.partition("s") #字符串按照第一个s进行分割，分三份 (包含分割元素s)

a.split("s") #a.split("s"，2) 按照s进行分割，2为分割次数 (不包含分割元素s）

a.splitlens() #按换行符分割

a.find("ex",start=None, end=None) #找到第一个对应字符串的索引,默认是找整体，也可单独指定判断位置（找不到返回-1）

(a.index()与find相同，但找不到报错 )

a.endswith("x") #以判断x结尾

a.startswith("x",start=None, end=None)#判断以x开头，默认是找整体，也可单独指定判断位置

a.isalnum() #判断字符串中包含数字或字符

a.isalpha()#判断是否是字符

a.isdeciml() #判断是否是数字（10进制数字）

a.isdigit()#判断是否是数字，支持特殊形式

a.isdentifier() #判断字母、数字、下划线

a.islower()#判断是否小写

a.isupper()#判断是否是大写

a.isnumeric()#判断是否是数字支持特殊字符（中文）

a.isprintable() #判断是否包含不可显示的字符如：\t \n

a.isspace() #判断是否全部是空格

a.istitle() #判断是否是标题

a.replace("xx","oo") #xx替换oo

a.join(xxx) #字符串拼接，a作为拼接符，重新拼接xxx (" ".join(xx） "xx".join(dd))

a.format(name="xxxx") #替换name

a.format_map

a.encode() #编码 str转换bytes

a.decode() #解码获得字符串类型对象

2.4、列表（list）

列表是python中的基础数据类型之一，列表是有序的，有索引值，可切片，方便取值。其基本操作有：索引、切片、追加、删除、长度、切片、循环、包含

2.4.1、创建列表：

a=["name","age","job","addr"]

2.4.2、增加

li = ["a","b","c"]

li.append("d") #增加到末尾

print(li)

li.insert(0,"aa") #按索引位置增加

print(li)

li.extend(['q,w,e']) #迭代增加

print(li)

li.extend('w')

li.extend('p,l,m')

print(li)

执行结果：

2.4.3、删除

li = ["a","b","c"]

l1 = li.pop(1) #按照位置去删除，有返回值，默认删除最后一个值

print(l1)

print(li)

del li[1:3] #按照位置去删除，也可切片删除没有返回值。

print(li)

li.remove('a') #按照元素去删除

print(li)

执行结果：

2.4.4、改

li = ["a","b","c","d"]

li[1] = 'dfasdfas'

print(li)

li[1:3] = ['b1','c1']

print(li)

执行结果：

2.4.5、查

切片去查，或者循环去查，与str的切片、索引相同

2.4.6 其他补充：

li = []

li.reverse() #将当前列表反转

li.sort() #排序默认从小到大

li.sort(reverse=True) #从大到小

li.copy() #浅拷贝

li.count(xxx) #计算元素xxx出现的次数

li.index(xx) #根据元素值获取其索引位置

li.clear() #清空列表

2.5、字典（dict）无序

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

创建字典：

dict = {"k1":"v1","k2":"v2"}

2.5.1、增加

dic = {"k1":"v1","k2":"v2"}

dic['li'] = ["a","b","c"]

dic.setdefault('k','v') #在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。

print(dic)

执行结果：

2.5.2 、删除

dic = {"name":"crazyjump","age":18,"job":"民工"}

dic_pop = dic.pop("a",'无key默认返回值') # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值

print(dic_pop)

print(dic)

del dic["name"] # 没有返回值。

print(dic)

dic_pop1 = dic.popitem() # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回

print(dic_pop1)

print(dic)

dic_clear = dic.clear() # 清空字典

print(dic,dic_clear) # {} None

执行结果：

2.5.3、改

dic = {"name":"crazyjump","age":18,"job":"民工"}

dic1 = {"age":20,"k":"v"}

dic.update(dic1) # 将dic1所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic中

print(dic)

执行结果：

2.5.4、查

dic = {"name":"crazyjump","age":18,"job":"民工"}

value = dic["name"]

print(value)

print(dic.get("n")) #key值不存在返回None

print(dic.get("s",12 )) #值不存在，返回定义的12

dic.setdefault("x","z") #不存在就新增，存在获取当前值

print(dic.setdefault("name","z"))

print(dic)

执行结果：

2.5.5、字典的循环

dic = {"name": "crazyjump", "age": 18, "job": "民工"}

for k, v in dic.items():

print(k, v)

for k in dic.items():

print(k)

for k in dic.keys():

print(k)

for v in dic.values():

print(v)

for k in dic:

print(k)

执行结果：

2.5.6、补充（可迭代对象）

dic = {"name":"crazyjump","age":18,"job":"民工"}

l = dic.items()

print(l)

k = dic.keys()

print(k)

v = dic.values()

print(v)

执行结果：

2.6、元组（tuple）

元组不可被修改，不能被增加或者删除。但可以被查询，字符串的切片操作同样适用于元组

新建元组：

tu=(11,22,33,"aaa")

2.7、集合（set）

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

去重，把一个列表变成集合，就自动去重了。

关系测试，测试两组数据之前的交集、差集、并集等关系。

2.7.1、创建集合：

set1 = set({1,2,'xxx'})

set2 = {1,2,'xxx'}

2.7.2、增加

set1={"a","b",12,"c"}

set1.add("d") #增加

set1.update('A') #迭代增加

print(set1)

set1.update('哈哈')

print(set1)

set1.update([1,2,3])

print(set1)

执行结果：

2.7.3、删

set1={"a","b",12,"c"}

set1.pop() #删除任意一个

set1.remove(12) #删除指定xx，指定的元素不存在会报错

set1.discard("xx") #删除指定xx ，指定的元素不存在不会报错

print(set1)

set1.clear() #清空集合

print(set1)

执行结果：

补充：集合查询使用循环即可

2.7.4、集合的其他操作

2.7.4.1、交集（& 或者 intersection）

set1 = {1,7,8,4,5}

set2 = {4,5,6,7,8}

print(set1 & set2)

print(set1.intersection(set2))

执行结果：

2.7.4.2、并集（| 或者 union）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 | set2)

print(set2.union(set1))

执行结果：

2.7.4.3、差集。（- 或者 difference）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 - set2)

print(set1.difference(set2)) #set独有的

执行结果：

2.7.4.4、反交集。（^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 ^ set2)

print(set1.symmetric_difference(set2))

执行结果：

2.7.4.5、子集与超集

set1 = {1,2,3}

set2 = {1,2,3,4,5,6}

print(set1 < set2)

print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)

print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。

2.7.4.6、frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')

print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'})

三、数据类型总结

3.1、数字：不可变，直接访问

3.2、字符串：不可变，顺序访问

3.3、列表：可变、有序、顺序访问

3.4、字典：可变、无序、key值访问

3.5、元组：不可变、有序、顺序访问

3.6、布尔值：不可变

3.7、集合：无序、不重复

补充

一、格式化输出：

1.1、%s

name = input('你的姓名：')

age = input('你的年龄：')

job = input('你的工作：')

info = "欢迎 %s，你的年龄是：%s ，你的工作是：%s "%(name,age,job)

print(info)

执行结果：

%s就是代表字符串占位符，除此之外，还有%d是数字占位符，%f是浮点数，如果把上面的age后面的换成%d，就代表你必须只能输入数字，否则就会报错 (另%3==3%%)

1.2、srt.format()

a = "{},{}".format("hello","world")

# 默认顺序

b = "{1},{0},{1}".format("hello","world")

#指定顺序

c = "{name},{age}".format(name="crazyjump",age=12)

print("a:",a)

print("b:",b)

print("c:",c)

执行结果：

二、for 循环（用户按照顺序循环可迭代对象的内容）：

msg = "crazyjump"

for item in msg:

print(item)

data = [1,2,3,4]

for item in msg:

print(iterm)

三、enumrate为可迭代的对象添加序号

li = ['a','b','c','d','e']

for i in enumerate(li):

print(i)

for index,name in enumerate(li,1): #索引默认从0开始，可改成1开始

print(index,name)

执行结果：

四、range 指定范围，生成指定数字。

for i in range(1,10):

print(i)

for i in range(1,10,2): # 步长

print(i)

for i in range(10,1,-2): # 反向步长

print(i)

五、深浅拷贝

5.1、浅拷贝（id() 对象的内存地址）

li = ["a", "b", ['crazy', 'jump']]

l1 = li.copy()

print(li, id(li))

print(l1, id(l1))

li[1] = "c"

print(l1, id(l1))

print(li, id(li))

li[2][0] = 'DB'

print(l1, id(l1[2]))

print(li, id(li[2]))

执行结果:

对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

5.2、深拷贝

import copy

l1 = ["a",['crazy','jump']]

l2 = copy.deepcopy(l1)

print(l1,id(l1))

print(l2,id(l2))

l1[0] = 222

print(l1,id(l1))

print(l2,id(l2))

l1[1][0]="db"

print(l1,id(l1[1]))

print(l2,id(l2[1]))

执行结果：

对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变

python数字类型及运算_Python基础之（基本数据类型及运算）相关推荐

python数字类型分为三类_Python ｜数据类型
Python让Python成为语言研究的利器Xu & YangPhoneticSan学习参考 Python for Linguists Natural Language Processing ...
python序列类型举例说明_Python基础__Python序列基本类型及其操作（1）
本节考虑的Python的一个中要的内置对象序列, 所谓的序列即一个有序对象的集合.这里的对象可以是数字.字符串等.根据功能的不同将序列分为字符串.列表.元组,本文将以下这几种对象做一些介绍. 一. 字 ...
python变量类型是集合_python基础-基本数据类型：集合
# 集合:它也是一种容器类型,可以存储多个数据,表现形式: {1, 3, 4, ...} # 集合的作用:1.利用集合对容器类型的中数据可以去重 # 2.利用集合进行关系运算 # 集合特点: # 1. ...
python中不同类型的数据不能相互运算_Python第三课——数据类型与运算(2)
hello大家好,我是你们的小蒟蒻鸭,终于终于有时间写博客了(虽然刚开始期末复习),真的非常非常抱歉,拖更太厉害了.反正还有一个月不到小蒟蒻就要放暑假了!!!(激动.jpg),蒟蒻保证会一周两篇,绝不 ...
[转载] python tuple类型如何索引_Python基础数据类型——tuple浅析
参考链接: Python tuple() Python中tuple的使用一.什么是元组? 有序列表叫元组:tuple.tuple和list非常类似,但是tuple一旦初始化就不能修改. 二.用法 1 ...
python数字和运算符空格_Python基础——运算符与数据结构（200315）
<34> rpartition(): --根据指定字符对字符串进行分割,保留指定字符,从右边开始,只分三份 <35>split('对象','个数'): - ...
4j是合法python数字类型_python数字类型
在python中,数据采用了对象的形式(无论是python内置对象还是使用python工具和像C语言自行创建的对象). Python数字类型工具:整数和浮点数复数固定精度的十进制数有理分数集合 ...
Practical Python基础1（数据类型，运算，比较符号，字符串，列表，函数等）
Practical Python基础1(数据类型,运算,比较符号,字符串,列表,函数等) Python是一种解释性的高级编程语言.它通常被归类为"脚本语言",被认为类似于Perl. ...
python的四种内置数字类型_浅析Python数字类型和字符串类型的内置方法
一.数字类型内置方法 1.1 整型的内置方法作用描述年龄.号码.id号定义方式 x = 10 x = int('10') x = int(10.1) x = int('10.1') # 报错内 ...
python内置类型方法_浅析Python数字类型和字符串类型的内置方法
一.数字类型内置方法 1.1 整型的内置方法作用描述年龄.号码.id号定义方式 x = 10 x = int('10') x = int(10.1) x = int('10.1') # 报错内 ...

python数字类型及运算_Python基础之（基本数据类型及运算）

python数字类型及运算_Python基础之（基本数据类型及运算）相关推荐

最新文章

热门文章