2 Python基础数据类型

Python基础数据类型

# 数据类型分为可变数据类型和不可变数据类型
    # 可变数据类型:list、set、dict 不可哈希
    # 不可变数据类型:str、int、bool、tuple(元祖) 可哈希

基本类型和数据集

基本类型

int

数字型:int 1,2,3,56
取值范围为:-2\*\*31~2**31-1
可以进行的运算:+ - * / **(幂次方) %(取余)
type() 查看数据类型

str

字符串:str

python中只要是用引号引起来的全是字符串

字符串转化成数字的条件: 字符串必须全是数字 int(str)

数字转化成字符串:str(int)

字符串可以相加:就是字符串的拼接

a = ‘我爱‘
b =  ‘中国‘
print(a+b)

字符串可以相乘:str*int

a = ‘坚强‘
b = 8
print(a*b)

字符串的换行:‘‘‘内容‘‘‘ 或者 """内容"""

msg = ‘‘‘
 鹅 鹅 鹅
 白毛浮绿水
 红掌波清波
 曲项向天歌
‘‘‘
print(msg)

字符串的索引和切片

s = ‘jokerORroot‘
s1 = s[0]  # 索引
s2 = s[0:2] # [首:尾] 切片  顾头不顾尾
s3 = s[0:4:2] # [首:尾:步长] 有规律的去 
# 倒着取
s = ‘jokerORroot‘
s1 = s[::-1]  #倒着取全
print(s1)
s2 = s[:2:-1]
print(s2)
s3 = s[3::-2]
print(s3)
s4 = s[3:1:-2]
print(s4)
s5 = s[3:1:-1]
print(s5)

运行结果为:
toorROrekoj
toorROre
eo
e
ek

常见字符串的操作方法

str操作 作用效果
capitalize() 首字母大写,其他全部小写
upper() 全部大写
lower() 全部小写
swapcase() 大小写反转
title() 每个单词的首字母大写
center(20,‘#‘) 总长度为20 填充物为# 字符串并居中
startswith() 判断字符串以什么开头
endswith() 判断字符串以什么结尾
len() 判断字符串的长度
find() 通过元素找索引,找到会返回第一个元素的索引,找不到返回-1
index() 通过元素找索引,找到会返回第一个元素的所以,找不到会报错
strip() 默认删除的是空格,删除字符串两边的字符,要删除特殊的字符只需strip(‘特殊字符‘)即可,rstrip() 默认从右往左删 lstrip() 默认从左往右删
count() 数出要数的元素在字符串中有多少个 可以切片
format 格式化输出
split() 将str分割成列表 默认的分割是空格
replace() 替换 replace(‘旧‘,‘新‘,‘要替换的次数‘) 不写次数 默认全部替换
isalnum() 判断字符串由字母或数字组成(True或False)
isalpha() 判断字符串只由字母组成(True或False)
isdigit() 判断字符串只由数字组成(True或False)

bool

bool:布尔值 True False
0 空集合 空字典 空列表 空字符串 -->False 非空即为True

float

float:浮点型 1.0 2.12

数据集

list

基本语法格式
Lst = [‘item1‘,‘item2‘,‘item3‘,...,num1,num2..,,[],{}]
list()  # 强制转化成list类型
list方法
  • append(追加在最后)
li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
li.append(‘jooker‘)
li.append(‘root‘)
print(li)
运行结果为:
[‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘taibai‘, ‘jooker‘, ‘root‘]
  • insert(插入,在索引的位置加入)

    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    li.insert(4,‘jooker‘)
    print(li)
    运行结果为:
    [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘jooker‘, ‘taibai‘]
  • extend(迭代增加)
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    li.extend(‘jooker‘)
    print(li)
    运行结果为:
    [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘taibai‘, ‘j‘, ‘o‘, ‘o‘, ‘k‘, ‘e‘, ‘r‘]
  • pop(按索引去删,有返回值,默认删除最后一个元素)
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    li.pop() # 有返回值 默认删除最后一个
    li.pop(1) # 指定删除 按照索引
    print(li)
    运行结果为:
    [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘]
    [‘alex‘, ‘egon‘, ‘女神‘, ‘taibai‘]
  • remove(按元素删)
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    li.remove(‘taibai‘)
    print(li)
    运行结果为:
    [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘]
  • clear(清空列表)
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    li.clear()
    print(li)
    运行结果为: []
  • del(在内存中删除列表,或者切片删除列表中的元素)
li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
del li  # 删除整个列表
print(li)
运行结果为:

li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
del li[1:3] # 切片删除
print(li)
运行结果为:[‘alex‘, ‘女神‘, ‘taibai‘]
  • 按照索引改(其实就是先删除然后再添加)
li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
li[0] = ‘jooker‘
print(li)
运行结果为:[‘jooker‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘taibai‘]
  • 切片改

    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    li[0:4] = ‘jooker‘
    print(li)
    运行结果为:[‘j‘, ‘o‘, ‘o‘, ‘k‘, ‘e‘, ‘r‘, ‘taibai‘]
  • for循环遍历查
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    for i in li:
    print(i)
  • 切片查
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    print(li[1:4])
  • 公共方法
    li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
    l = len(li)  # 获取列表的长度
    num = li.count(‘taibai‘)  # 就算列表中指定元素出现的次数(即指定元素的个数)
    ret = li.index(‘女神‘)  # 查看元素的的索引(即列表中元素的下标) 列表只能用index 而不能用find
    li.sort()  # 正向排序 默认是按照ascii码表顺序排
    li.sort(reverse=True)  # 反向排序
    li.reverse()  # 反转

    set

    语法格式
set1 = {‘value1‘,‘value2‘}
set() # 强制转化成集合
# 集合的特性
    # 集合是可变的数据类型
    # 集合里面的元素必须是不可变的数据类型
    # 集合是无序的
    # 集合里面的元素是不能重复的
set方法
  • add

    set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
    set1.add(‘女神‘)
    print(set1)  # {‘alex‘, ‘女神‘, ‘egon‘, ‘ritian‘, ‘barry‘, ‘wusir‘}
  • update 迭代增加(即先打散在增加)
    set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
    set1.update(‘abc‘)
    print(set1)  # {‘c‘, ‘wusir‘, ‘barry‘, ‘a‘, ‘b‘, ‘ritian‘, ‘alex‘, ‘egon‘}
  • pop 随机删除,有返回值
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.pop()
print(set1) # {‘egon‘, ‘barry‘, ‘alex‘, ‘wusir‘}
  • remove 按元素删
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.remove(‘alex‘)
print(set1)  # {‘wusir‘, ‘barry‘, ‘egon‘, ‘ritian‘}
  • clear 清空集合
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.clear()
print(set1)  #set()
  • del 删除整个集合

    set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
    del set1
  • 只能用for循环进行遍历查询
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
for i in set1:
    print(i)
交集
  • &
  • intersetion()
    set1 = {1,2,3,4,5}
    set2 = {2,4,6,8,10}
    set3 = set1 & set2
    print(set3)  #  {2, 4}
    set4 = set1.intersection(set2)
    print(set4)  #  {2, 4}
并集
  • |
  • union()
    set1 = {1,2,3,4,5}
    set2 = {2,4,6,8,10}
    set3 = set1 | set2
    print(set3)  # {1, 2, 3, 4, 5, 6, 8, 10}
    set4 = set1.union(set2)
    print(set4)  # {1, 2, 3, 4, 5, 6, 8, 10}
    反交集
  • ^
  • symmetric_difference()
set1 = {1,2,3,4,5}
set2 = {2,4,6,8,10}
set3 = set1 ^ set2
print(set3)  # {1, 3, 5, 6, 8, 10}
set4 = set1.symmetric_difference(set2)
print(set4)  #  {1, 3, 5, 6, 8, 10}
差集
  • -
  • difference()
set1 = {1,2,3,4,5}
set2 = {2,4,6,8,10}
set3 = set1 - set2
print(set3)  # {1, 3, 5}
set4 = set1.difference(set2)
print(set4)  # {1, 3, 5}
子集

注意:返回的结果为True 或 False

  • <
  • issubset
set1 = {1,2,3}
set2 = {1,2,3,4,5}
set3 = set1 < set2
print(set3)  # True
set4 = set1.issubset(set2)
print(set4) # True
超集
  • \>
  • issuperset
    set1 = {1,2,3}
    set2 = {1,2,3,4,5}
    set3 = set2 > set1
    print(set3)   # True
    set4 = set2.issuperset(set1)
    print(set4)  # True
    去重
    li = [1,2,33,33,2,1,4,5,6,6]
    set1 = set(li)
    print(set1)   #  {1, 2, 33, 4, 5, 6}
    li = list(set1)
    print(li)  # [1, 2, 33, 4, 5, 6]
    frozenset

    将结合转变成不可变的数据类型 无序的 只能查询

s = frozenset(‘jooker‘)
print(s,type(s))  # frozenset({‘j‘, ‘o‘, ‘e‘, ‘k‘, ‘r‘}) <class ‘frozenset‘>

dict

语法格式
dic = {‘key1‘:‘value1‘,‘key2‘:‘value2‘}
# 特性
    # dict的key必须是不可变数据类型 即是可哈希的
    # dict的value可以是任意数据类型
# 优点
    # 用二分法去查找数据,查询的速度快
    # 存储大量的关系型数据
dict方法
  • 直接赋值
dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1[‘height‘] = 185  # 若不存在 则会直接添加

dic1[‘age‘] = 16  # 若存在该建 则会将value覆盖
  • setdefault(有键值对的不做任何改变,没有才添加)
dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1.setdefault(‘height‘,185) # 没有的键值对 进行增加

dic1.setdefault(‘age‘,16)  # 存在有键值对 则不做任何改变
  • pop(删除有返回值,并且可以设置返回值)
dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
print(dic1.pop(‘age‘))  # 有返回值
dic1.pop(‘age‘)

dic.pop(‘name1‘,‘没有此键值‘)  # 设置返回值
  • popiten(删除有返回值,且是随机删除的,返回值是元祖)
dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1.popitem() # 随机删除
print(dic1)

print(dic1.popitem())  # 返回值是元祖
  • del(从内存中删除)

    dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
    del dic1
  • clear(清空字典)
dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1.clear()  # 运行结果为:{}
  • 直接改(即覆盖)

    dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
    dic1[‘age‘] = 16
  • update
dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic2 = {‘name‘:‘alex‘,‘weight‘:185}
dic2.update(dic1)  #将dic2中的数据进行更新
print(dic1)
print(dic2)

运行结果为:
{‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘}
{‘age‘: 18, ‘weight‘: 185, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘}

# get方法(设置找不到值的返回值)
print(v2) #打印会报错

# 使用get方法,查找key,找不到返回一个自定义的值
print(dic.get(‘name1‘,‘没有这个键‘))
dic = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic.keys()  # 输出字典中的key
dic.values # 输出字典中的value
dic.items # 输出字典中的键值对

for i in dic:
    print(i)  # 默认打印key

for i in dic.keys():
    print(i)  # 打印key

for i in dic.values():
    print(i)  # 打印value

for i in dic.items
    print(i) # 打印键值对 打印的结果默认是元祖的形式

for i,k in dic.items():
    print(i)  # 不以元祖的形式打印

tuple

注意:若元祖中只有一个元素,且不加逗号,则改元素是什么类型就是什么类型

tu = (1)
tu1 = (1,)
print(tu,type(tu)) # 运行结果为:1 <class ‘int‘>
print(tu,type(tu1)) # 运行结果为:1 <class ‘tuple‘>
1 <class ‘int‘>
语法格式
tu = = (value1,value2,value3)
tuple()  # 强制转化成元祖
  • 元祖是只读列表,可以循环查询,可以切片
  • 元祖中有可变数据类型,该元素可以改变
tuple方法
  • for循环遍历查

    tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
    for i in tu:
    print(i)
  • 切片查
    tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
    print(tu[0:5])
  • 按照索引查
    tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
    print(tu[3])

    注意:元祖的改变只能是在元祖有可变的数据类型时才能改变

    tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
    tu[4][3] = ‘jooker‘

原文地址:http://blog.51cto.com/lzhnb/2323214

时间: 2024-10-11 17:22:10

2 Python基础数据类型的相关文章

Python基础数据类型考试题

# Python基础数据类型考试题 # 考试时间:两个半小时 满分100分(80分以上包含80分及格) # 一,基础题. # 1, 简述变量命名规范(3分) # 1.变量由字母.数字.下划线任意组成 # 2.不能以数字开头 # 3.不能使用python关键字 # 4.变量要具有可描述性 # 5.变量不能是中文 # 5.官网推荐骆峰体和下划线,这里推荐下划线 # 2,字节和位的关系.(2分) # 1字节 = 8位 # 3,'太白'使用utf-8编码时,占的位数和字节数,是多少?使用gbk编码时,占

Python基础数据类型之字符串

Python基础数据类型之字符串 一.Python如何创建字符串 在python中用引号将一些文本包起来就构成了字符串(引号可以是单引号.双引号.单三引号,双三引号,它们是完全相同的) >>> str1 = 'hello' >>> str2 = "hello" >>> str3 = '''hello''' >>> str4 = """hello""" &g

Python基础数据类型题

Python基础数据类型 题考试时间:三个小时 满分100分(80分以上包含80分及格)1,简述变量命名规范(3分) 1.必须是字母,数字,下划线的任意组合. 2.不能是数字开头 3.不能是python中的关键字 4.变量不能是中文 5.变量不能过长 6, 变量要具有可描述性 2,字节和位的关系.(2分)8位等于1个字节3,'A太白'使用utf-8编码时,占的位数和字节数,是多少?使用gbk编码时,占的位数和字节数,是多少.(2分)'A太白'使用utf-8编码时,占56位和7个字节,使用gbk编

python基础数据类型----整数 ,字符串【常用操作方法】,布尔值,for循环

Python基础数据类型(4.29) bool str int 三者之间的转换 str索引切片,常用操作方法 for循环(大量的练习题) 1.基础数类型总览 整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set). 10203 123 3340 int 主要用于计算+- * / 等等 '今天吃了没?' str 存储少量的数据,并进行相应的操作.str1 + str2, str *int , 索引,切片, 其他操作方法 Tru

python基础数据类型补充以及编码进阶

01 内容大纲 基础数据类型的补充 数据类型之间的转换 编码的进阶 02 具体内容: 数据类型的补充: str # str :补充的方法练习一遍就行. s1 = 'taiBAi' # capitalize 首字母大写,其余变小写 print(s1.capitalize()) # swapcase 大小写翻转 print(s1.swapcase()) # title 每个单词的首字母大写 msg= 'taibai say3hi' print(msg.title()) s1 = 'barry' #

python基础数据类型补充以及编码的进阶

一. 基础数据类型补充内容 1.1 字符串 字符串咱们之前已经讲了一些非常重要的方法,剩下还有一些方法虽然不是那么重要,但是也算是比较常用,在此给大家在补充一些,需要大家尽量记住. #captalize :首字母大写 #swapcase :大小写翻转 #title :每个单词的首字母大写 #center :内同居中,总长度,空白处填充 #寻找字符串中的元素是否存在 #find :返回的找到的元素的索引,如果找不到返回-1 #index :返回的找到的元素的索引,找不到报错. #captalize

python基础数据类型初始,用户交互

一.基础数据类型初始 1.数字:int  1,2,3 1 print(100,type(100)) 2 print('100',type('100')) 查看数据类型的方法:type()函数 取值范围: int(整型) 在32位机器上,整数的位数为32位,取值范围为-2**31-2**31-1,即-2147483648-2147483647 在64位系统上,整数的位数为64位,取值范围为-2**63-2**63-1,即-9223372036854775808-922337203685477580

python 基础数据类型 一

基础数据类型 一 整数:在python3中用关键字int来表示 在32位机器上int的范围是: -2**31 2**31-1,即-2147483648-2147483647 在64位机器上int的范围是: -2**63-2**63-1,即-9223372036854775808-9223372036854775807 在python3中所有的整数都是int类型. 但在python2中如果数据量比较大. 会使用long类型. 在python3中不存在long类型 整数可以进行的操作+ - * /

python基础--数据类型、运算符、流程控制

原文地址:https://www.cnblogs.com/dukeidea/p/6362031.html https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000    廖雪峰的python教程 一 初识Python python是一种面向对象.解释型的计算机程序语言.Python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿