python逻辑型数据也叫什么_python数据类型和运算

常见数据类型和运算

1 变量的命名规范

'''只能以字母，数字，下划线组成，不能以数字开头。命名时 避免与系统关键字重复，关键字：['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']长变量名建议使用下划线组成在一起，如：name_of_owen多个单词的简写建议全用大写，ege; URL | HTTP'''

2 常见的数据数据类型

整形 int

py3中所有整形都用int来表示 py2中长整形用long类型存储

浮点型 float

用来存储小数的

salary=888888.0123456789

# 可以通过格式化方式来绝对输出格式

# %.6f % salary

# 1）%f对浮点型数据进行占位

# 2）.后的数据数字表示小数精度

# 3）.前的数据是输出的长度，小于等于要输出的数据长度不起作用，超出就采用规定的最大长度

# 注：%015.6f：右对齐，左侧不足拿0填充， %-15.6f: 左对齐输出

print('%015.6f' % salary)

# 了了解

# 可以将格式化的结果进行保存，以便之后再次使用

info = '%015.6f' % salary

print(info)

%s是万能占位符, %是用来连接有占位符的字符串与需要占位的变量，多个变量用()包裹

info = """信息:name:%sage:%s""" % (name, age)

print(info)

布尔 bool

True 真 数字1也代表

False 假 None 和 0 都为False

字符串 str

单行字符串; " " | ' '

多行字符串： """ """ | ''' '''

列表 list

# 1、定义：变量名 = [多个值，之间用,隔开]

ls = [3, 1, 2]

# 2、列表变量名ls访问的是列表整体

print(ls) # [3, 1, 2]

# 3、通过索引(index)来访问具体的值，index从0开始编号： ls[index]

print(ls[0]) # 3

# 4、ls的嵌套及值的访问

ls = [[1, 2, 3], [4, 5, 6], [7, 8, [9]]]

# 访问数字9

print(ls[2][2][0])

# 重点：list存放值的方式： eg：[3, 1, 2] => 列表的0号位存放的不是数字3，而是堆区3空间的地址 索引都是从0开始的

字典 dict

# 定义：{}是用来定义字典的语法，key是用来描述最终要访问的value值的，key对于开发者来说是已知的

# 访问：通过 dic[key]来访问key描述的值

dic = {'key': 'value'}

元祖 (x,)

元祖：只读列表，只能查询；儿子不能改，孙子是列表则可以改

只有一个元素，不加逗号，是原数据类型；否则是元祖类型

集合 set

集合：可变的数据类型，里面的元素必须是不可变的数据类型 　 无序----每次运行结果都不一定一样 　 不重复----列表去重：先转换为集合，再转换成列表即可

3 运算符

算术运算符

\# + | - | * | / | // | ** | %

\# 1.字符串和list可以做 + 和 *

\# 2./非整除，// 为整除

# 3.**求幂：5 ** 2 => 25

\# 4.任意数 % n => [0, n-1] 取模（余）的公式

\# 5.有负数参与的取余：符号跟着 % 后面那个数

比较运算符

# == 等于 != 不等于 >= <= > <

赋值运算符

# += 依次相加 *= %= //=

1 链式赋值

a = b = num

2 交叉赋值

x = 10

y = 20

x,y = y,x

print(x,y) # 20 10

3 解压赋值

ls = [3, 1, 2]

a, b, c = ls

# _是合法的变量名，会接受值，但我们认为_代表该解压位不用接收，用_来接收表示

_, _, g = ls # g才存放2，其他表示不接受

逻辑运算符

# and | or | not

# 1.and: 左右都成立才成立，有不成立的就不成立

# 2.or: 左右都不成立才不成立，有成立的就成立

# 3.ont: 成立则不成立，不成立则成立

res = 0 and 20 # and前为假，整个式子就可以确定为假了，and后就不需要执行(短路)

print(res) # 0

res = 10 or 20 # or前为真，整个式子就可以确定为真了，or后就不需要执行(短路)

print(res) # 10

res=0 and 20 ===>0 整数时，and为假时，直接为前面值 res= 20 and 0 ===>20 整数时，and为真时，后面值覆盖前面值 所以结果为20 .

and优先级大于or

4 数据类型操作

1 字符串操作

1.字符串的索引取值: 字符串[index]

# 正向取值从0编号，反向取值从-1编号

res = '12345'

print(res[0]) # 1

res = '1,2 ,3, 4, 5'

print(res[0]) # 1

res = '1,2 ,3, 4, 5'

print(res[-1]) # 5

2.字符串拼接

ls1 = '1,2345'

ls2 = 'abcde'

res = ls1 + ls2

print(res) # 1,2345abcde

# 拼接其他类型

s1 = 10

s2 = 'abc'

s3 = True

#res = s1+s2+s3

#print(res) # 报错 不是同类型

res = str(s1) + s2 + str(s3) # 正确 10abcTrue 这种情况只能转化为字符串 不能‘abc’转化为整数类型

res = '%s%s%s' % (s1, s2, s3) # %s 万能占位符 位置一一对应

3.字符串长度

res = '10abcTrue'

print(len(res)) # 9 字符串长度为9

print(len(res[0])) # 1

4 字符串切片:

取子字符串 [::数字] [start_index:end_index:step] 表示索引从某某开始到某某结束，以多少步长计算

res = '123456abc'

print(res[0::]) # 表示从0号位开始到结束 123456abc

print(res[0:6:]) # 123456 表示从0号位开始到6号位结束 则是 123456

print(res[3:7:]) # 456a

print(res[::-1]) # cba654321 # 符号表示倒叙取值

print(res[::-2]) # ca531 # 倒叙2步取值

print(res[-1:-6:-1]) # cba65 倒叙 取五位值

5.成员运算：判断某字符串是否在该字符串中 （in 和 not in）

res = '123456呵呵'

ls5 = '呵呵'

print(ls5 in res) # True

print(ls5 not in res) # False

6 字符串循环。涉及for循环

res = '123456呵呵'

for i in res:

print(i) # 1 2 3 4 5 6 呵 呵 打印出来每个都是一行

字符串重要方法

# 1.索引(目标字符串的索引位置)

s1 = '123abc呵呵'

print(s1.index('b')) # 4 表示b对应的位置是从0到4的位置

# 2.去留白(默认去两端留白，两端没有空格时也可以去两端指定字符) res.strip()

res = ' ***anc * 789*** '

print(res.strip()) # ***anc*789*** 把两端的空格去掉了

res = ' ***anc * 789*** '

print(res.strip('*')) # ***anc * 789*** 当两端有空格时，还是只能取空格

res = '***anc * 789***'

print(res.strip('*')) # anc * 789 两端无空格的情况下 去掉两端的*字符

# 3.计算子字符串个数 len(res)

res = '***anc * 789***'

print(len(res)) # 15

# 4.判断字符串是否是正整数 res.isdigit

res = '12345'

print(res.isdigit()) # True

# 判断是否是负数 首先判定首字母是-号，在判断后面是不是正整数

res = '-12345'

if res.startswith("-") and res[1::].isdigit(): # 首先判断是否是负数 然后在判断-号后面的数就好 ，所以从1开始

print('负数')

# 5.大小写转换 res.lower() 转化为小写 | res.upper() 转为大写

res = 'aBCdEFf'

print(res.lower()) # 转化为全小写 abcdeff

print(res.upper()) # ABCDEFF

# 补充 res.islower() 判断是不是小写 | res.isupper()判断是不是大写

print(res.islower()) # False

print(res.isupper()) # False

# 6.以某某开头或结尾

res = '12345wsx345'

print(res.startswith("123")) # True

res = 'wsx1234edc789'

print(res.endswith('78')) # False

# 7.替换 res.replace('y','x',数字) 表示x将替换y, 数字表示将替换几次

res = 'egon say he is 逗比,egon egon egon!'

print(res.replace('egon', 'lxx')) # lxx 替换egon 默认替换所有 lxx say he is 逗比,lxx lxx lxx!

print(res.replace('egon', 'lxx', 3)) # lxx 替换egon三次 lxx say he is 逗比,lxx lxx egon!

# 8.格式化 只能格式化掉{}的内容

s8 = 'name：{}，age：{}'

print(s8.format('owen', 18)) # name：owen，age：18 # 默认按位置去掉空字典

print('name：{1}，age：{0}, height：{1}'.format('Owen', 18)) # name：18，age：Owen, height：18

# 指定位置 name：{1}指的是被format（）里的索引1的位置值18代替 age：{0}指的是被format（）后面索引的0位置的owen代替

print('name：{n}，age：{a}, height：{a}'.format(a=18, n="Zero")) # name：Zero，age：18, height：18

# 指名道姓

# 其他格式

s7 = '123wsx'

print(s7.isalnum()) # True 由字母和数字组成的

s9 = '1234'

print(s9.isalnum()) # True 由字母和数字组成的

s10 = '123qaz' # .isalpha判断是否是字母组成

print(s10.isalpha()) # False

# 1. find | rfind：查找子字符串索引，无结果返回-1

# 2. lstrip：去左留白

# 3. rstrip：去右留白

# 4. center | ljust | rjust | zfill：按位填充

# 语法：center(所占位数, '填充符号')

# 5. expandtabs：规定\t所占空格数

# 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转

# 7. isdigit | isdecimal | isnumeric：数字判断

# 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成

# 9. isidentifier：是否是合法标识符

# 10. islower | isupper：是否全小 | 大写

# 11. isspace：是否是空白字符

# 12. istitle：是否为单词首字母大写格式

2 列表操作

列表：

names = ['a','b','c','d']

1、追加：names.append()

>>> names.append('e')

>>> names

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

2、删除：pop，remove，del

1）pop()

如果没有指定下标，则默认会删除最后一个元素

>>> names.pop()

'e'

指定下标时，就会删除下标所对应的元

>>> names.pop(2)

'c'

2）remove()

>>> names.remove('e')

>>> names

['a', 'b', 'c', 'd']

3）del

>>> del names[4]

>>> names

['a', 'b', 'c', 'd']

3、查找元素所在位置：index()

>>> names.index('c')

2

4、统计元素的次数：count()

>>> names.append('d')

>>> names.count('d')

2

5、反转：reverse()

>>> names.reverse()

>>> names

['d', 'c', 'b', 'a']

6、清空：clear()

>>> names.clear()

>>> names

[]

7、插入：insert()

>>> names.insert(2,'devilf')

>>> names

['a', 'b', 'devilf', 'c', 'd']

还有其他的插入方法：

>>> names[3] = 'lebron'

>>> names

['a', 'b', 'devilf', 'lebron', 'd']

8、排序：sort()按照ascii码来进行排序

>>> names.insert(4,'&&')

>>> names

['a', 'b', 'd', 'devilf', '&&', 'lebron']

>>> names.sort()

>>> names

['&&', 'a', 'b', 'd', 'devilf', 'lebron']

9、列表拼接：extend()

>>> names.extend(place)

>>> names

['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

10、列表切片

1）列出所有的元素

>>> names[::]

['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

2）列出最后一个元素，从中间位置开始，列出后面所有的元素

>>> names[-1]

'usa'

>>> a = int(len(names)/2)

>>> names[a:]

['devilf', 'lebron', 'beijing', 'shandong', 'usa']

11、复制：copy()

>>> names.copy()

['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

另外的几种复制的方法：

>>> info = ['name',['a',100]]

>>> n1 = copy.copy(info)

>>> n2 = info[:]

>>> n3 = list(info)

在使用copy.copy()时，需要导入copy模块

这些均是浅copy

例如：

>>> info

['name', ['a', 100]]

>>> n1 = info[:]

>>> n2 = copy.copy(info)

>>> n1

['name', ['a', 100]]

>>> n1[0] = 'devilf'

>>> n2[0] = 'lebron'

>>> n1;n2

['devilf', ['a', 100]]

['lebron', ['a', 100]]

>>> n1[1][1] = 80

>>> n1

['devilf', ['a', 80]]

>>> n2

['lebron', ['a', 80]]

这里可以看到修改n1列表中的值，n2中的值也会跟着改变，这就是浅copy,也就是说，浅copy会复制原列表的内存地址，也就是说，我们修改了n1和n2，就是修改了指向同一内存地址的对象，所以info列表会变化，n1和n2都会变化，例如：

>>> info

['name', ['a', 80]]

5 字典操作

字典类型

容器(集合)：存放多个值的变量

单列容器(系统中的单列容器很多)：list | tuple

双列容器(map)：只有dict，存放数据 成对出现，dict存放数据采用 key-value键值对方式

字典中的key可以为什么类型：key必须为不可变类型

-- key是取value的唯一依据，key一旦被确定，就需要唯一确定(不能被改变)

字典中的value可以为什么类型：value可以为任意类型

-- value是用来存放世间所有存在的数据

key要确保唯一性，不能重复，值可以重复，并且可以被改变 => 字典为可变类型

dic = {'a': 10, 1: 20, True: 30, (): 40} # 1和True都是1，key具有唯一性，所以只保留最后一次值 print(dic) # {'a': 10, 1: 30, (): 40}

字典的创建

空字典

d1 = {} d2 = dict()

用map映射创建字典

d3 = dict({'a': 1, 'b': 1}) print(d3)

用关键字赋值方式

d4 = dict(name='Bob', age=18) # 参数=左侧的名字就是合法的变量名，都会被转化为字符串形式的key print(d4)

创建有多个key值采用默认值的方式: 默认值不写默认None，也可以自定义

d5 = {}.fromkeys('abc', 0) print(d5)

字典的操作

dic = {'a': 1, 'b': 2} print(dic)

增:

字典名["key"] = 值 => key已存在就是修改值，不存在就是新增值

dic['c'] = 3

print(dic)

改

dic['c'] = 30 print(dic)

查:字典名[key]

print(dic['c']) # 只能查找已有的key，没有崩溃

有默认值的查询：有key取出对应value，没有返还默认值，默认值可以自定义

print(dic.get('d', 'http://www.baidu.com'))

删

print(dic)

清空

dic.clear()

pop(k)删除指定key的value并返还删除的value

res = dic.pop('a')

# 从dic末尾删除，返还(key, value)形成的元组

res = dic.popitem()

print(dic, res)

更新:

a有值覆盖，c没被新操作，带下来，b为新增，增加并赋值

dic = {'a': 1, 'c': 2}

d = {'a': 10, 'b': 20}

dic.update(d)

print(dic) # {'a': 10, 'c': 2, 'b': 20}

带默认值的新增: 新增key，key已有，啥事不干，没有添加key，值就是第二个参数

dic.setdefault('z', 100)

print(dic)

字典的循环

1.直接循环，就是循环得到key

# for k in dic:

# print(k)

2.循环keys

# print(dic.keys())

# for k in dic.keys():

# print(k)

3.循环values

# print(dic.values())

# for v in dic.values():

# print(v)

同时循环key和value (key, value)

print(dic.items())

# a, b = (1, 2)

# print(a, b)

# for res in dic.items():

# print(res)

重点 解压赋值

for k, v in dic.items(): print(k, v)

a, ,, b = (1, 2, 3, 4)

6 元祖操作

元组：可以理解为不可变的列表

# 1.值可以为任意类型

# 2.可以存放多个值 - 可以进行成员运算

# 3.可以存放重复的值 - 可以计算成员出现的次数

# 4.有序存储 - 可以通过索引取值，可以切片

# 常用操作

# 1.索引取值

print(t1[1], type(t1[1]))

print(t1[-3])

# 2.运算(拼接)

print((1, 2) + (2, 3))

# 3.长度

print(len(t1))

# 4.切片

print((2, 1, 3)[::-1])

# 5.成员运算

print(True in t1)

print(False in t1) # False == 0， t1中如果有0或False，该结果都是True

# 6.for循环

for obj in t1:

print(obj, end=" ")

print()

# 方法

print(t1.count(0)) # 对象0在元组中出现的次数

print(t1.index(123, 4, len(t1))) # 对象0在区间4~末尾第一次出现的索引

7 集合操作

集合类型

# 空集合：不能用{},因为用来标示空字典

s = set()

print(s, type(s))

# 概念：

# 1.set为可变类型 - 可增可删

# 2.set为去重存储 - set中不能存放重复数据

# 3.set为无序存储 - 不能索引取值

# 4.set为单列容器 - 没有取值的key

# 总结：set不能取值

# 增

s.add('1')

s.add('2')

s.add('1')

print(s)

s.update({'2', '3'})

print(s)

# 删

# res = s.pop()

# print(res)

# s.remove('1')

# print(s)

s.clear()

print(s)

# set运算

# 交集：两个都有 &

py = {'a', 'b', 'c', 'egon'}

lx = {'x', 'y', 'z', 'egon'}

print(py & lx)

print(py.intersection(lx))

# 合集：两个的合体 |

print(py | lx)

print(py.union(lx))

# 对称交集：抛出共有的办法的合体 ^

print(py ^ lx)

print(py.symmetric_difference(lx))

# 差集：独有的

print(py - lx)

print(py.difference(lx))

# 比较：前提一定是包含关系

s1 = {'1', '2'}

s2 = {'2'}

print(s1 < s2)

5 深浅拷贝

值拷贝 ：ls = [1,2,3] res = ls 则print（res）就是[1，2，3]

浅拷贝 ：ls.copy()

深拷贝：ls3 = deepcopy(ls) # 新开辟列表空间，ls列表中的不可变类型的地址直接拿过来，但是可变类型的地址一定重新开辟空间 # ls内部的所有类型的值发生改变，ls3都不会随之变化

可变对象 指 可以在原处修改，而不用创建新的对象(包括列表，字典，集合)； 不可变对象指 不支持在原处修改，只能通过表达式创建新的对象，然后把结果分配给变量(包括 数字，字符串，元组)。

6 数据类型的转换

数字类型之间的转化

主要关注两个用法

join 组合 用于 列表转为字符串

split 拆分 字符串和列表都可以使用

字典与其他之间的转化 间接转化

1 转化为数字类型

res = int('10') # 字符串转化为数字

print(res)

res = int('-3')

print(res)

res = float('.15')

print(res) # 0.15

res = float('-.15')

print(res) # -015

res = float('-3.15')

print(res) # -3.15

2:字符串与列表相互转换 (重要)

s = 'abc123呵呵'

print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵'] 字符串转列表

ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

n_s = '.'.join(ls) # 列表转字符串 ''.join()

print(n_s) # a.b.c.1.2.3.呵.呵

#

s = 'abc123呵呵'

print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

n_s = ''.join(ls) # 这是没有点号的显示

print(n_s) # abc123呵呵 这是没有点号的显示，点好也可以转换为其他

#

s1 = 'a b c 1 2 3 呵 呵'

res = s1.split() # 把字符串转化为列表 默认按空格拆

print(res) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

s2 = 'ie=UTF-8&wd=你好帅'

res = s2.split('&') # 字符串改列表

print(res) # ['ie=UTF-8', 'wd=你好帅'] split默认按空格来隔开，s2.split('&')则是把&两边分开为列表,中间可以是其他的，

# 比如- 或8，只要是在s2里就行

ls2 = ['ie=UTF-8', 'wd=你好帅']

n_s2 = '@'.join(ls2)

print(n_s2) # ie=UTF-8@wd=你好帅 ''.join() 中''可以加其他的 比如@ 或4 则列表组合中间多一个其他

# 4:需求："ie=UTF-8&wd=你好帅" => [('ie', 'UTF-8'), ('wd', '你好帅')]

res = []

s4 = "ie=UTF-8&wd=你好帅"

ls4 = s4.split('&') # ['ie=UTF-8', 'wd=你好帅']

for ele in ls4: # v = ie=UTF-8 | wd=你好帅 for 循环把每个值取出来

k, v = ele.split('=') # k: ie v: UTF-8 赋值 k ,v = ele.split('=')

res.append((k, v))

print(res)

# 5.需求："ie=UTF-8&wd=你好帅" => {'ie': 'UTF-8', 'wd': '你好帅'}

res = {}

s5 = "ie=UTF-8&wd=你好帅"

ls5 = s5.split('&') # ['ie=UTF-8', 'wd=你好帅']

for ele in ls5:

k, v = ele.split('=') # 去掉 =

res[k] = v # 添加字典的模式 res[k] = v 如果字典中res，有k这个，则把值v赋值给k,如果没有，则在字典中添加k:v

print(res) # {'ie': 'UTF-8', 'wd': '你好帅'}

# 6.需求：[('ie', 'UTF-8'), ('wd', '你好帅')] => {'ie': 'UTF-8', 'wd': '你好帅'}

res = {} # 建立新的空字典

ls6 = [('ie', 'UTF-8'), ('wd', '你好帅')]

for k, v in ls6:

res[k] = v

print(res)

3.list与tuple、set直接相互转化 - 直接 类型()

# 8.需求：将汉字转化为数字

# 将 壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟

# 转化为 1、2、3、4、5、6、7、8、9、10、100、100

# 作业：壹仟捌佰玖拾叁 => 1893

num_map = {

'壹': 1,

'贰': 2,

'仟': 1000

}

ls8 = ['贰', '壹', '仟']

res = []

for v in ls8:

num = num_map[v] # 通过key去映射表拿到对应的值，完成 '贰' => 2

res.append(num)

print(res)