python基础之数据类型

一 数字类型 Int Float Long

二 布尔类型

三 字符串类型

message= "Have agood time";

3.1 str.endswith(suffix[, start[, end]])： 判断结尾

# 判断是否以某字符串结尾print(message.endswith('me'))# 截取字符串[前开后闭]是否以某字符串结尾print(message.endswith('ve',2,4));print(message.endswith('time',11));

 

3.2 str.startwith(prefix[, start[, end]])：判断开始

# 判断是否以某字符串开始print(message.startswith('Have'))# 截取字符串[前开后闭]是否以某字符串结尾print(message.startswith('Have', 0, 4));

 

3.3 判断是否全是小写或者全是大写

str.islower()：

message[0:4].islower()

str.isupper():

message[0:4].isupper()

 

3.4 将字符串全部转换成小写或者大写

print(message[0:4].lower())print(message[0:4].upper())

 

3.5 判断字符串中每一个单词是否以大写开始的，字符串如果不包含字母则返回False

print("你好".istitle()) # 不包含字母返回Falseprint("你好,Have A Good Time".istitle()) # 每一个单词以大写开始，返回Trueprint("Have a Good Time".istitle()) # a 不是以大写开始，返回False

 

3.6 判断字符串是否只是包含文字[包括汉字]以及数字，如果全是返回True,否则包含其他字符则返回False

print("你好123".isalnum())print("~你好123".isalnum()) # 包含非文字或者数字，返回Falseprint("ABC你好123".isalnum())

 

3.7 str.isalpha()判断字符串是否只是包含文字字符，包括中文字符，也就是说不能有数字或者其他特殊的字符

print("你好123".isalpha()) #返回Falseprint("abc你好".isalnum()) # 包含文字，返回Trueprint("#你好3".isalnum()) #返回False

3.8 str.isspace(): 判断字符串是否只包含空格或者制表符

print(''.isspace()) #空字符并不是空格返回Falseprint('\t  '.isspace()) #只包含制表符和空格，返回True

3.9 判断是否是数字或者数字字符

str.isdecimal()：

str.isdigit()：

str.isnumeric()：

3.10 对字符串进行编码

#将字符串以utf-8格式进行编码。str.encode(encoding="utf-8", errors="strict")

3.11 str.swapcase()：字符串中字符大小写互换

# 大小写互换print("hELLO，你好".swapcase())

Hello，你好

3.12 str.capitalize()：字符串首字母大写，其余小写

# 字符串首字母大写，其余全部转为小写print("i Love you".capitalize())I love you

3.13 str.title(): 将字符串中没有个单词首字母转化为大写

print("i Love you".title())

I Love You

3.14 str.center(width[,fillchar]): 返回一个原字符串居中，长度为width的新字符串，width要大于原始字符串的长度，否则返回原字符串，原字符串开头和结尾处使用fillchar进行填充，默认为空格。

注：width为偶数时，fillchar将平均地填充到原字符串的开头和结尾；为奇数时，fillchar优先填充前面

# width要大于字符串长度，否则原始字符串返回;fillchar不填默认就是空格print("abcd".center(2)) # 返回abcd\print("abcd".center(5)) # 返回 abcdprint("abcd".center(5,'*')) # 返回 *abcdprint("abcd".center(6,'#')) # 返回 #abcd#

3.15 根center类似，根据原始串添加指定的字符原始字符串左对齐和右对齐

# str.ljust(width[, fillchar])：原始字符左对齐，填充的字符全在右边print("abcd".ljust(5,'*')) # 返回 abcd*print("abcd".ljust(6,'*')) # 返回 abcd**# str.rjust(width[, fillchar])：原始字符右对齐，填充的字符全在左边print("abcd".rjust(5,'*')) # 返回 *abcdprint("abcd".rjust(6,'*')) # 返回 **abcd

3.16 删除字符串第一次匹配到的指定字符

# str.lstrip([chars])：从左边开始，字符串第一次匹配到的chars字符，要被移除，不指定默认是空格print("# I Love You M".lstrip("# I ")) # 返回 Love You M# str.rstrip([chars])：从右边开始，字符串第一次匹配到的chars字符，要被移除，不指定默认是空格print("# I Love You M".rstrip(" M")) # # I Love You# str.strip([chars]): 左右两边都包含.字符串第一次匹配到的chars字符，要被移除，不指定默认是空格print("#I Love You#".strip("#")) # I Love You

3.17 str.expandtabs([tabsize])：字符串中制表符替换为指定个数的空格，默认是8个

print("I\tLove you".expandtabs(1)) #I Love youprint("I\tLove you".expandtabs(4)) #I   Love you

3.18 str.count(sub[, start[, end]])：统计某个子串在字符串中出现的个数，sub为子串，start 和 end表示统计范围

print("Python 2.x is different from Python 3.x"

.count("Python"))print("Python is good language，Python perfect"

.count("Python",8,))

3.18 str.find(sub[, start[, end]])：从左边开始查找查找子字符串在字符串中出现的第一个位置，start和end指定一个查找范围。未找到返回-1

print("nicky 11 baobao 11 wawa 11".find("11")) # 6print("nicky 11 baobao 11 wawa 11".find("11",8,)) # 16

3.19 str.rfind(sub[, start[, end]])：从右边开始查找查找子字符串在字符串中出现的第一个位置，start和end指定一个查找范围。未找到返回-1

print("nicky 11 baobao 11 wawa 11".rfind("11")) # 24

3.20 str.format(*args, **kwargs):调用fortmat方法的字符串中不但有纯文本，也有使用{}界定符包括起来的替换字段。替换字段既可以是位置参数的数值索引，也可以是字典或属性的Key值。该方法返回的字符串里，所有替换字段都被相应参数的值所替代

print("I love you {0}, {1}".format("宝宝","forever"

))print("I love you {nickname}： {presentor}".format(

nickname="宝宝",presentor = "你的欧巴"))

3.21 str.index(sub[, start[, end]]): 计算子串在字符串中的第一次出现的索引位置

print("I Love you".index("you"))

print("I Love you".index("you",2,))

3.22 str.partition(sep) ：该方法用于拆分字符串，返回一个包含三个元素的元组。如果未能在原字符串中找到Sep，则元组的三个元素为：原字符串，空串，空串；否则，从原字符串中遇到的第一个Sep字符开始拆分，元组的三个元素为：Sep之前的字符串，Sep字符，Sep之后的字符串

str.rpartition(sep): 与str.partition(sep)一样，只不过是从右边开始切分的

# 结果('tran', 'sl', 'ation')print("translation".partition('sl'))

# 结果('translation', '', '')print("translation".partition('he'))

3.23 str.split([sep[, maxsplit]])： 字符串切割，从左边开始

str.rsplit([sep[, maxsplit]])：字符串切割，从右边开始

注意：

# maxsplit表示最大分割次数，比如第一次分割之后，可能分割部分还包含这个分割，你又想继续分割，你就可以指定2次

# 如果没有指定分割符，那么首尾的空格会去掉

# 如果指定分割符，但是字符串不包含这个分隔符，那么首尾的空格不会去掉

print("I Love You".split(" "))

print("I Love You".split("o",1))print("I Love You".split(" "))print("I Love You".split("o",1))

3.24 str.splitlines([keepends])：拆分一个包含多行的字符串，以每行为一个元素返回一个列表。如果字符串不是多行的，则返回原字符串。keepends是一个True字符或非零整数，表示保留行尾标志。该方法多用于处理文件

四 列表

创建列表的语法

fruits = ['apple','pear','orange','banana']animals = list('tiger','lions','cat','dog')

4.1 列表的长度

len(list)

4.2 列表的组合和扩展

组合：两个列表相加产生一个新的列表

fruits = ['apple','pear','orange','banana']animals = ['tiger','lions','cat','dog']collection = fruits + animals

扩展: listA.extend(listB) 将一个列表的数据添加到另外一个列表

animal_1 = ['tiger','lions','cat','dog']animal_2 = ['pig','snake','hadoop','hive']animal_1.extend(animal_2)

4.3 列表的重复与复制

列表的重复：listA = listB * 2

animal_1 = ['tiger']

animal_3 = animal_1*2

['tiger','tiger']

列表的复制：listA = listB.copy()

4.4 判断list 是否包含某一个元素

element in list

4.5 迭代列表

for item in list

            print item

4.6 读取列表数据和分片

fruits = ['apple','pear','orange','banana']print(fruits[0]) # apple# 分片前开后闭print(fruits[0:2]) #['apple', 'pear']# 截取数据从下表2开始，一直到最后print(fruits[2:]) # ['orange', 'banana']# 截取最后2个元素print(fruits[-2:])  # ['orange', 'banana']# 截取倒数4个-倒数第2个元素print(fruits[-4:-1])

4.7返回列表元素最大值 最小值

max(list)：print(max(fruits1))

min(list): print(min(fruits1))

4.8 元组和列表互相转化

fruits = ['apple','pear','orange','banana']animals = (1,2,3,4,5)# 将元组转化为列表animal_list = list(animals)# 将列表转化为元组fruit_tuple = tuple(fruits)

4.9 计算列表的索引

# 计算元素的索引位置print(fruits.index('banana'))

4.10 列表末尾追加元素

# 列表末尾追加元素fruits.append('watermelon')

4.11 在指定position位置插入元素

# 在指定position位置插入元素fruits.insert(1,'mango')

4.12 移除列表中的一个元素

# 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值fruits.pop() # 删除mangofruits.pop(0) # 删除apple

4.13 根据指定元素删除元素

# 根据指定的元素进行删除fruits.remove("pear")

4.14 反转列表

# 反转列表元素fruits.reverse()

4.15 对列表排序

# 对列表排序fruits.sort()

4.16 统计某个元素出现的次数

# 计算某个元素出现的次数print(fruits.count('apple'))

五 字典

创建字典的语法

'''每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。键必须独一无二，但值则不必。值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。'''instructments = {'1000': 'Gibson Guitar', '1001': 'Gibson Bass', '1001': 'Yamaha Pinao','1004': 'Finder Bass'}

5.1 访问字典

print(musics['1000'])

print(musics.get('1001', 'null'))

5.2 修改字典

musics['1000'] = 'B.C.AR Bass'musics['1004'] = 'Yamaha Keyboards'print(musics)

{'1000': 'B.C.AR Bass', '1001': 'Gibson Bass', '1002': 'Yamaha Pinao', '1003': 'Finder Bass', '1004': 'Yamaha Keyboards'}

5.3 删除

删除某一个元素

del(musics['1000'])print(musics)

清空字典

musics.clear()

删除整个字典

del(musics)

5.4 常用的字典方法

# 字典常用方法# 计算字典元素个数print(len(musics))# 删除字典内所有元素#musics.clear()# 返回一个字典的浅复制music_dict = musics.copy()# 根据一个指定的序列或者列表，以其内容作为key，然后与提供一个默认的初始值作为valuekey = [1,2,3,4]value = 'init value'fromdict = musics.fromkeys(key,value)# 结果 {1: 'init value', 2: 'init value', 3: 'init value', 4: 'init value'}print(fromdict)# 以列表返回可遍历的(键, 值) 元组数组# 结果dict_items([('1000', 'Gibson Guitar'), ('1001', 'Gibson Bass'), ('1002', 'Yamaha Pinao'), ('1003', 'Finder Bass')])print(musics.items())# 以列表返回一个字典所有的键print(musics.keys())# 以列表的形式返回所有vlauesprint(musics.values())# 把另外一个字典更新到当前字典musics = {'1000': 'Gibson Guitar', '1001': 'Gibson Bass', '1002': 'Yamaha Pinao','1003': 'Finder Bass'}music_map = {'1000': 'Gibson Electirc Guitar','1005':'Finder keyboards'}musics.update(music_map)print(musics)

5.5 字典的遍历

fruit_dict = {'A':'apple','B':'Balana','M':'mamgo','P':'pear'}for key in fruit_dict.keys():    print(fruit_dict.get(key))for value in fruit_dict.values():    print(value)

六 元组

elements = (1,2,3,4)

# 元组一般用于只读,元组的元素不可以修改。

# 元组的元素的元素是可以修改的，比如：

t1 = (1, 2, {'k1':'v1'})t1[2]['k1'] = 'v2'print(t1[2]['k1'])

所以它有两个重要方法

Index:计算元素在元组的索引位置

Count:计算指定元素在元组中出现的次数

七 set 集合

创建set集合的语法：

list1 = [1,3,4];list2=[2,3,4]
s1 = set(list1)
s2 = set(list2)

# 计算集合长度
len(s1)

# 添加元素
s1.add(5)
s2.add(6)

# 删除元素
s1.remove(3)
print(s1)
s1.discard(4)
print(s1)
s1.pop() # 最后一个元素被删除，并且返回这个元素

# 清空set
s1.clear()

# set浅拷贝
copySet = s1.copy()


# 两个set集合取交集,
interSet1 = s1.intersection(s2)
print(s1) # {1, 3, 4, 5}
print(interSet1) # {3, 4}

# 两个set集合的交集,并且将结果更新原始的set
s1.intersection_update(s2)
print(s1) # {3, 4}

# 将两个集合进行比较，将比较的集合里面的元素在第二个集合没有出现的重新构成一个新的集合
fruits_1 = ['apple','watermelon']
fruits_2 = ['apple','orange','mango']
fruit1_set = set(fruits_1)
fruit2_set = set(fruits_2)
diff_set1 = fruit1_set.difference(fruit2_set)
print(diff_set1)

# 原始集合和其他集合比较，用原始集合不同的部分更新为原始集合，原始集合的之前数据丢弃
diff_set2 = fruit1_set.difference_update(fruit2_set)
print(diff_set2)

# 判断是否包含交集,如果免密钥交集返回TRUE，有的话返回FALSE
result = fruit1_set.isdisjoint(fruit2_set)
print(result) #返回false

animal_1 = ['tiger','lion']
animal_2 = ['tiger','lion','hadoop']
aset1 = set(animal_1)
aset2 = set(animal_2)

# 判断第一个集合是否是另外集合的子集合
result = aset1.issubset(aset2)
print(result) #返回true

# 判断某个集合是否包含某一个集合
result = aset2.issuperset(aset1)
print(result) #返回true

# 获取两个集合的差集作为新的集合
symSet1 = aset1.symmetric_difference(aset2)
print(symSet1) # {'hadoop'}因为只有hadoop

# 获取两个集合的差集然后把这个差集更新为原始集合，原始集合的数据丢弃
aset1.symmetric_difference_update(aset2)
print(aset1) #

# 并集
unionSet = aset1.union(aset2)
print(unionSet) # {'lion','hadoop', 'tiger'}

# 将其他集合数据用来更新原始集合
aset1.update(aset2)
print(aset1)

八 Collection系列数据结构

8.1  计数器(Counter)

Counter是对字典类型的补充，用于追踪值的出现次数

具备字典所有功能+自己的功能，也就是说对字典做了扩展

import collections

counter = collections.Counter('asbasdfggfhasdasasada')

print(counter)

# 只是取得前几位

ret = counter.most_common(3)

print(ret)

# 遍历counter字典

for k,v in counter.items():

    print(k,v)

8.2 有序字典OrderedDict

也是对字典的扩展，记住了字典元素的添加顺序

dic = collections.OrderedDict()

dic['k1'] = 'v1'

dic['k2'] = 'v2'

dic['k3'] = 'v3'

print(dic)

8.3 默认字典

defaultdict是对字典类型的扩展，它默认给字典设置 了一个类型

# defaultDict 就是给dict的value设置一个默认的类型

default_dic = collections.defaultdict(list)

values = [12,23,89,34,68,88,67,23,55]

for v in  values:

    if v > 50 :

        default_dic['k1'].append(v);

    else:

        default_dic['k2'].append(v);

print(default_dic)

8.4 可命名元组

命名元组就是对元组的扩展

# 命名元组

# 首先创建一个类

UserInfo = collections.namedtuple('UserInfo',['userName','passowrd','age','gender','address'])

# 在根据创建的类产生对象

user = UserInfo("Nicky","19870612","28","male","1000# Edward Street")

# 访问元组

print(user.userName + user.passowrd)

8.5 队列

8.5.1 双向队列

import collections

de = collections.deque();

# 添加数据 append appendleft

de.append('nicky') # 往右边添加

de.appendleft('hello') #往左边添加

# 在指定的位置插入数据

de.insert(1,'tiger')

# 扩展 extend extendleft

de.extend(['hadoop','hive','kylin'])

de.extendleft(['beeline'])

# 取索引位置

index = de.index('hive')

index = de.index('hive',1,10)

# 去某个值出现的次数 count

de.count('nicky')

# 浅拷贝

cde = de.copy()

# 删除元素

de.pop() # 取出队尾的元素

de.remove('hive')

# 自己从队列尾部拿数据插入队首

de.rotate()

# 队列反转

de.reverse()

# 清空对列

de.clear()

8.5.2 单向队列

import queue

q = queue.Queue()

# 插入数据

q.put('hadoop');

q.put('hive')

q.put('impala')

q.put('hue')

# 队列元素个数

size = q.qsize()

# 取数据 先进先出

element = q.get()

print(element)

# 查看是否空了

q.empty()

# 查看是否填满了

q.full()