python基础-基础数据类型

 一 介绍

1. 基础数据类型

1.1 数字int---整型

数字主要是用于计算，使用方法较少，记住一种：

　

#bit_bit_length()
i = 3
print(i.bit_length())  #转化成二进制后，占用多少位

 

 

1.2 布尔值bool

布尔值只有两种True与False，判断真假

bool

"""
字符串的转化

int ---> str:  str(int)
str ---> int:  int(str) str必须全是数字组成

int ---> bool:  0 False  非零 True
bool ---> int  int(True) --> 1  int(False) --> 0

str ---> bool： ''：False  非空字符串：True
 
print(bool("")) False   #空字符串
print(bool("   ")) True   #非空字符串
  
"""

 

 

1.3 字符串str

1.3.1 字符串的索引

 索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

s = 'python自动化运维21期'  #字符串是有索引的 ，索引是角标

s1 = s[0]
print(s1)   # p

print(s[2])  # t

print(s[-1])  # 期

 

1.3.2 字符串的切片

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

原则：顾头不顾尾

s = 'python自动化运维21期' 

# s[起始索引:结束索引+1:步长]

print(s[0:6]) # python  #顾头不顾腚，首位0可省略不写

print(s[:6])  # python


print(s[0:5:2])  # pto
print(s[:5:2])   # pto

print(s[:])    #python自动化运维21期
print(s[:-1])  #python自动化运维21

#倒着取
print(s[-1:-5])   ## 空，倒着取的话必须加反向步长
print(s[-1:-5:-1])   ## 期12维

 

1.3.3 字符串的增删改查、常用方法

s = 'olDBoy'

* 首字母大写，其他字母小写

s1 = s.capitalize()
print(s1) #Oldboy

# *** 全部变成大写upper()  验证码
s2 = s.upper()
print(s2) #OLDBOY

# *** 全部变成小写 lower() 验证码
s3 = s2.lower()
print(s3) #oldboy

# * 大小写反转
s4 = s.swapcase()
print(s4) #OLdbOY

# * 非字母隔开的每个单词首字母大写
st = 'alex wusir*oldboy3taibai'
s5 = st.title()
print(s5)  #Alex Wusir*Oldboy3Taibai


s.center()  #居中, 长度自己设定，默认填充空格
#使用方法：
def center(self, width, fillchar=None):  # real signature unknown; restored from __doc__
    """
    S.center(width[, fillchar]) -> str

    Return S centered in a string of length width. Padding is
    done using the specified fill character (default is a space)
    """
    return ""
s6 = s.center(30)
print(s6)   #(            olDBoy      )
s6 = s.center(30,"*")
print(s6)   #(************olDBoy************)

 

 

 

 

# startwith endwith  判断是否以。。。开头或者结尾，返回布尔值

s = 'olDBoy'
s7 = s.startswith('o')
print(s7)  #True

s7 = s.startswith('ol')
print(s7)  #True

s7 = s.startswith('Boy',3,)
print(s7)   

## 源码中看到  start=None, end=None  代表有切片功能

def startswith(self, prefix, start=None, end=None):  # real signature unknown; restored from __doc__
    """
    S.startswith(prefix[, start[, end]]) -> bool

    Return True if S starts with the specified prefix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    prefix can also be a tuple of strings to try.
    """
    return False

 

# *** strip  去除首位的空格、制表符\t、换行符\n。不仅仅是去除空格

s = '  olD\tBoy\n  '
s8 = s.strip()
print(s8)

username = input('>>>').strip()   ##在用户输入的时候，务必使用strip方法，防止用户输入前后多输入空格
if username == 'oldboy':
    print("验证成功")

# lstrip 只去除左边的  rstrip  只去除右边的
#  split  将字符串变为列表(默认空格，可以以任何形式隔开 分割  split可设置切割次数

s = 'oldboy wusir alex'
l = s.split('o')
print(l)

s = 'sbcde sbcde sfes dsrda'
print(s.split('e')) 

 

 

# # join  将列表转化为字符串

s = 'oldBoy'
s9 = '+'.join(s)
s91 = '-'.join(s)
print(s9,s91)  #o+l+d+B+o+y o-l-d-B-o-y

l1 = ['eldboy','wusir','alex'] ## join可对列表进行操作
s91 = '='.join(l1)
print(s91)  #eldboy=wusir=alex

s = '大铁锤fsdb铁锤妹妹'
#将铁翠替换成钢蛋

# replace
s10 = s.replace('铁锤','钢蛋')   #
print(s10)   #大钢蛋fsdb钢蛋妹妹

#find index  几乎一样的方法  通过元素找索引
#通过字符串的位置，找到对应的方法
s = 'oldBoy'
ind = s.find('d')   #找不到时返回-1
int = s.index('d')  ##找不到，会报错
print(ind)
print(int)

 

 公共方法

s = 'sfasfasfasf'
print(len(s))  ##计算字符串s的长度
s = 'addfadggadfdsa'
print(s.count('d'))  ##统计d的个数

 

格式化输出 format

res = '我叫{}，今年{}，爱好{}'.format('wph',28,'male')
print(res)

res = '我叫{0}，我的年纪{1}，我的名字是{2}'.format('wph',28,'ball')
print(res)

res = '{sex} {name} {age}'.format(sex='man',name='wph',age=18)
print(res)

 

 is 系列

name = 'jinxing123'
print(name.isalnum())  ##p判断字符串由字母或者数据组成
print(name.isalpha())  ##判断字符串只由字母组成
print(name.isdigit())  ##判断字符串由数字组成

 

 

1.4列表list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

1.4.1 列表的增删改查

l  = ['老男孩','alex','wusir','ritian']
# 增
#append 追加
# l.append('葫芦')
print(l)

print(l.append('葫芦'))  ##none  打印的是增加的动作

#insert 插入
l.insert(1,'景女神')
print(l)

## 迭代着增加
l.extend('alex')
print(l)

l.extend(['111',222,333])
print(l)

#pop  有返回值 按照索引去删
print(l.pop(0))
print(l)

#remove  按元素删除
l.remove('alex')
print(l)

# #clear  清空列表
# l.clear()
# print(l)

## del  内存级别删除列表、
# del l
# print(l)

#按索引去删
print(l)
del l[1]
print(l)

l  = ['老男孩','alex','wusir','ritian']

# 按索引改
print(l[2])
l[2] = '武藤兰'
print(l)
print(l[2])

# #按切片改
# l[:2] = 'abcv'  #将切片先替换，后添加
# print(l)

l[1:3] = [111,333,222]
print(l)

# 查
l  = ['老男孩','alex','wusir','ritian']

# 按照索引去查询 
# 按照切片去查询
# 循环查
for i in l:
    print(i)

1.4.2 列表的其他方法

l1 = [1,2,1,2,1,1,3,4]
# count计数
print(l1.count(1))  #列表中出现的次数
#len 测量长度
print(len(l1))     #测量列表的长度

# 通过元素找索引
print(l1.index(4))  #查找4的索引，只找到第一个就返回

l2 = [3,2,4,6,9,8,7,1]
#列表排序  sort
l2.sort()
print(l2)  #从小到大排序

l2.sort(reverse=True)  ##加参数 从大到小排列
print(l2)

#倒叙排列
l2.reverse()
print(l2)

 

1.4.3 列表的嵌套

l1 = [1,2,'alex','wusir',['oldboy','ritian',99],'taibai']

#1 将'alex'全部变成大写，放回原处，两种方法去做
l1[2] = 'ALEX'
l1[2] = l1[2].upper()

#2  给 ['oldboy','ritian',99]  追加一个元素
print(l1[-2])
l1[-2].append('景nvsheng')
print(l1)

#3  将'ritian'首字母大写，放回原处
print(l1[-2][1])
l1[-2][1] = l1[-2][1].capitalize()
print(l1)

#将99通过数字相加，或者字符串相加等等，变成字符串'100'

l1[-2][-2] = str(l1[-2][-2] + 1)
print(l1)

# 字符串相加 将10通过数字相加，或者字符串相加等等，变成字符串'100'
l1 = [1,2,'alex','wusir',['oldboy','ritian',10],'taibai']
l1[-2][-1] = str(l1[-2][-1]) + '0'
print(l1)

 

 

1.5 字典dict

1.5.1 字典介绍

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

　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典的查询速度非常快 符合二分查找
字典的key是唯一的 key必须是不可变的数据类型 
    key: 不可变的数据类型(可哈希)： str，bool，tuple，int
    value: 任意数据类型。
    数据类型分类
        不可变的数据类型(可哈希)： str，bool，tuple，int
        可变的数据类型：dict，list，set。
        容器类的数据类型： list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）
3.5及之前版本 字典是无序的，3.6及以后的版本，字典是有序的 

 

 1.5.2 字典的增删改查

dic = {'name':'taibai','age':'28','hobby':'girl'}

 

1.5.2.1 增

dict['high'] = 180   ##有则覆盖 ，无则添加  字典的改
print(dict)

dic.setdefault('high')   ##键为high，值为空none
print(dict)

dic.setdefault('high',180)   ## setdefault 有则不变，无则添加
print(dic)

 

 

1.5.2.2 删

dic.pop('name')  # 根据键值对的键 来操作删除】
print(dic.pop('name'))   #返回值 返回删除的对应键的值

dic.clear()  #清空字典

del  dic  #内存级别删除字典
print(dic)

del  dic['age']  #按键值删除
print(dic)

print(dic)
dic.popitem()  #随机删除 但是3.6是有序的了，就是从后往前删除
print(dic)
print(dic.popitem())  #打印返回值 返回的是一个元组  删除的键值对放在元组里

#pop可以删除不存在的键值对，但是不报错，返回指定结果
print(dic.pop('name1','没有此键'))
print(dic)

 

1.5.2.3 改

dic['name'] = 'oldboy'

#2 update
dic = {"name":"wph","age":"18"}
dic2 = {"name":"lq","sex":"women"}

dic2.update(dic)   #将dic的键值对覆盖增加到dic2
print(dic)
print(dic2)

 

1.5.2.4 查

print(dic['name'])  #查键对应的值，但是没有会报错。
print(dic.get('name1','NO Have'))   ##不报错

#循环查找
# 1.2.3 个方法
# keys()  values() items()

print(dic.keys())  # 把所有的放在一个容器里。可以转化成list 更好利用
print(list(dic.keys()))
for i in dic.keys():
    print(i)

dic.values()
print(dic.values())  #把所有的值放到一个容器里，可以转化成list 更好利用

for i in  dic.values():
    print(i)

print(dic.items())    #把键值对放到元组里，可以转化成列表
print(list(dic.items()))
for i in dic.items():
    print(i)

1.5.3 分别赋值

a = 1
a,b = 1,2
print(a,b)
a,b,c = ["alex","wusir","ritian"]
print(a,b,c)

# 一行代码将a b 互换
a = 1
b = 2
a,b = b,a
print(a,b)

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

1.5.4 公共方法

#len  键值对个数
print(len(dic))

 

 1.5.5 fromkeys

 # fromkeys 创建一个字典
dic1 = dict.fromkeys('abc','zhangshan')
dic2 = dict.fromkeys([1,2,3],'lisi')
print(dic1,dic2)

### 注意大坑！！！
dic3 = dict.fromkeys('abc',[])
print(dic3)
dic3['a'].append('王鹏鸿')
print(dic3)   ###会将‘王鹏鸿’加到每一个键值对中！坑

 

 1.5.6 字典的嵌套

dic = {
    'name_list':['b哥', '张帝', '人帅', 'kitty'],
    '老男孩':{
        'name':'老男孩',
        'age': 46,
        'sex': 'ladyboy',
    },
}

print(dic)

#1  给['b哥', '张帝', '人帅', 'kitty'] 追加一个元素'骑兵'

dic['name_list'].append('骑兵')
print(dic['name_list'])
print(dic)

#2  将kitty全部大写
dic['name_list'][-1] = dic['name_list'][-1].upper()
print(dic['name_list'])
print(dic)

#3  将 '老男孩'改成'oldboy'
dic['老男孩']['name'] = 'oldboy'
print(dic)

#4  将ladyboy首字母大写
dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)

 

 

1.6 元组

 一句话介绍： 可查不可改 元组不可改，但是儿子不可改孙子可改！

tu = (11,2,True,[2,3,4,],'alex')
#查
for i in tu:
    print(i)

print(tu[1]) #2
print(tu[:3:2]) #(11,True)

print(tu.index(True))

print(tu.count(2)) #计算数量
print(len(tu))  #计算元素数量

# 儿子不可改孙子可改
tu[-2].append(666)
print(tu)

 

 

 1.7 集合

1.7.1 集合的作用

集合专门用于处理数据，用处较少

'''
集合：
    无序不重复的数据类型
    里面的元素必须是可哈希的（不可变的） 但是集合本身是可变的
    1. 关系测试 交并集 子集 差集
    2. 去重 （列表的去重）

    很不重要！！！
'''

 

 

1.7.2 列表的常用方法-增、删、去重

set1 = {1,'alex',False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
set2 = list(set(l1))   #列表的去重
print(set2)

#增
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('666')
print(set1)

#update   #迭代增加
set1.update('abc')
print(set1)

#删
set1.remove('alex')  #按照元素去删
print(set1)

set1.pop() #随机删除一个元素
print(set1)

set1.clear() #清空集合

del set1    # 删除集合
print(set1)

 

 

 

 1.7.3 集合的关系测试

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

#交集
print(set1 & set2)  #生成一个新的交集
print(set1.intersection(set2))

#并集
print(set1 | set2)  #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))

#差集
print(set1 - set2)  #{1, 2, 3}  set1 独有的
print(set1.difference(set2))

#反交集
print(set1 ^ set2)  #{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))

#子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

#子集
print(set1 < set2)   #True
print(set1.issubset(set2))  #True
#超集
print(set2 > set1) #True
print(set2.issuperset(set1)) #True

###
# frozenset  冻 冻集合  集合变成不可变的数据类型
s = frozenset('barry')
print(s,type(s))   #frozenset({'y', 'a', 'b', 'r'}) <class 'frozenset'>

s1 = frozenset({4,5,6,7,8})
print(s1,type(s1))    #frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>

 

 

二 其他数据类型补充

2.1 数据类型补充

2.1.1 删除列表的奇数位元素

l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']

#删除列表的奇数位元素
#1
del l1[1::2]
print(l1)

#2
for i in l1:
    if l1.index(i) % 2 == 1:

#3 #在循环一个列表的时候，不要对列表进行删除的动作（改变列表元素的动作）
for i in range(len(l1)-1,-1,-1):  #5个元素 len(l1)-1
    if i % 2 == 1:
        # print(i)
        del l1[i]
print(l1)

2.1.2  range 可定制的数字列表

for i in range(10):
    print(i)

for i in range(1,10,2):
    print(i)

for i in range(10,1,-1):
    print(i)

print(range(10))

2.1.3 删除字典中元素的方法

# ##将含有k元素对应的键值对删除
# # # dict 在循环字典时，不要改编字典的大小
for i in dic:
    if 'k' in i:
        del dic[i]  ##改变大小会报错  ##可以先将字典改变为其他类型
l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
        # print(l1)
for i in l1:
    del dic[i]
print(dic)

 

2.1.4 不是元组的元组

#tu  如果元组里面只有一个元素，并且没有逗号隔开，那么它的数据类型与该元素一致。就不是元组了。
tu1 = (1)
print(tu1,type(tu1))  #1 <class 'int'>

tu2 = ('alex')
print(tu2,type(tu2))  #alex <class 'str'>

tu3 = (['alex',1,2])
print(tu3,type(tu3))  #['alex', 1, 2] <class 'list'>

 

 

2.2 小数据池

# id = = is

a = 'alex'
print(a)
b = 'alex'
print (a==b)  #数值
print (a is b)  #内存地址

#id 测内存地址
print(id(a),id(b))  #一定要在内存地址去试，pycharm会做优化  ab内存地址一样吗？？？


#小数据池的概念？
#int -5~256 的相同的数全部指向一个内存地址 节省空间
#str: s = 'a' *21  #单个字符 * 21  缺少具体范围。。。了解即可

# >>> a = 'A'*20
# >>> b = 'A'*20
# >>> print(a is b)
# True

# >>> a = 'A'*21
# >>> b = 'A'*21
# >>> print(a is b)
# False

# >>> a = 'alex'
# >>> b = 'alex'
# >>> print(a is b)
# True
# >>> a = 'alex#'  #含有非字母
# >>> b = 'alex#'
# >>> print(a is b)
# False