基础数据类型补充与总结

目录

• 基础数据类型补充与总结
  • 整型
  • 字符串
  • 列表
  • 元组
  • 字典
  • 类型转换
  • 基础数据类型总结

基础数据类型补充与总结

整型

.bit_length 方法用来计算整型数字转换为二进制所占的位数：

a = 10
print(a.bit_length())

输出的结果为： 4

这个方法的意思是，10 转换为二进制数是 1010，一共会占 4 位。

字符串

.capitalize() 方法

.capitalize() 方法用来将字符串的首字母大写：

s = 'alEX wusir'
s1 = s.capitalize()
print(s1)

输出的结果为：Alex wusir

.title() 方法

.title() 方法能将字符串每个单词的首字母大写，区分首字母的方式有空格、符号和数字等：

s = 'alEX wUsir-meET3san'
s1 = s.title()
print(s1)

输出的结果为：Alex Wusir-Meet3San

.index() 和 .find() 方法

.index() 方法用来通过元素查找索引，查找不到时会报错：

s = 'alex wusir'
print(s.index('e'))
print(s.index('wu'))

.find() 方法同样用来通过元素查找索引，与 .index() 方法不同的是，.find() 方法查找不到时会返回 -1，而不会报错：

s = 'alex wusir'
print(s.find('b'))
print(s.find('le'))

如果字符串中有多个要查找的元素片段，.index() 和 .find() 方法都只会找第一个元素的索引：

a = 'abcabc'
print(a.index('a'))
print(a.find('a'))

.center() 方法

.center() 方法用来进行居中操作，会在字符串两端插入等量的空格，使得字符串总长度等于输入的参数：

s = 'alex wusir'
print(s.center(20))

也可以指定两端填充的内容：

print(s.center(20, '-'))

输出的结果为：-----alex wusir-----

.format() 方法

.format() 方法是另外一种字符串格式化的方法：

s = 'alex{}wu{}si{}r'
s1 = s.format('你好', '我好', '大家好')
print(s1)

输出的结果为：alex你好wu我好si大家好r

.format() 方法除了向上面这种按照位置格式化之外，还可以按照索引格式化：

s = 'alex{0}wu{2}si{1}r'
s1 = s.format('你好', '我好', '大家好')
print(s1)

输出的结果为：alex你好wu大家好si我好r

.format() 方法还可以按照关键字进行格式化：

s = 'alex{a}wu{c}si{b}r'
s1 = s.format(b = '你好', a = '我好', c = '大家好')
print(s1)

输出的结果为：alex我好wu大家好si你好r

.swapcase() 方法

.swapcase() 方法可以反转字符串中字母的大小写：

s = 'alEx'
s1 = s.swapcase()
print(s1)

输出的结果为：ALeX

这里插入一个 PyCharm 的使用技巧：ctrl + shift + r 打开替换窗口。

列表

.reverse() 方法

对列表进行反转操作，我们可以通过切片的方式进行：

lst = [1, 2, 3, 4, 5, 6]
print(lst[::-1])

这种方法并没有对原来的列表进行修改，而是创建了一个新列表。如果我们想对原来的列表进行改动，可以将切片后的结果赋值给 lst。也可以使用 .reverse() 的方法，对列表本身进行原地的反转操作：

lst = [1, 2, 3, 4, 5, 6]
lst.reverse()
print(lst)

输出的内容为：[6, 5, 4, 3, 2, 1]

.sort() 方法

列表的 .sort() 方法可以将混乱的列表排序，默认是按照升序排序：

lst = [2, 1, 3, 4, 6, 5]
lst.sort()
print(lst)

输出的结果为：[1, 2, 3, 4, 5, 6]

我们可以混合使用 reverse 方法将升序的列表反转，达到降序的目的。也可以通过将 .sort() 方法中的参数 reverse 设置为 True，来让列表进行降序排序：

lst = [2, 1, 3, 4, 6, 5]
lst.sort(reverse=True)
print(lst)

输出的结果为：[6, 5, 4, 3, 2, 1]

.index() 方法

.index() 方法通过元素名来查找该元素在列表中的索引：

lst = [1,2,3,4,6,5]
print(lst.index(4))

输出的结果为： 3

需要注意的是，如果需要查询的元素在列表中不止一个，.index() 方法只会返回从左面数第一个元素的索引值：

lst = [1,2,3,4,4,6,5]
print(lst.index(4))

输出的结果仍然是： 3

列表的加法和乘法

跟字符串类似，列表也可以进行加法和乘法的操作：

lst1 = [1, 2, 3, [4]]
lst2 = [4, 5, 6]
print(lst1 + lst2)
print(lst2 * 3)

输出的结果为：
[1, 2, 3, [4], 4, 5, 6]
[4, 5, 6, 4, 5, 6, 4, 5, 6]

需要注意的是，列表的加法和乘法都是新开一个空间存储结果，而不是对原列表进行操作。但是加法和乘法的结果所使用的元素仍然是原列表中的。相应的操作与浅拷贝就很类似了：

lst1 = [1, 2, 3, [4]]
lst2 = [4, 5, 6]
l_sum = lst1 + lst2
l_sum[3].append(9)
print(lst1, lst2, l_sum)
l_multi = lst1 * 2
l_multi[3].append(8)
print(lst1, lst2, l_multi)

输出的结果为：

[1, 2, 3, [4, 9]] [4, 5, 6] [1, 2, 3, [4, 9], 4, 5, 6]
[1, 2, 3, [4, 9, 8]] [4, 5, 6] [1, 2, 3, [4, 9, 8], 1, 2, 3, [4, 9, 8]]

元组

元组需要补充的内容不是很多，只是需要掌握下面这三种小括号的含义即可：

tu = (10)    # int，括号中只有一个元素且没有任何逗号，那就表示该元素本身。此时，括号可以看成一个运算符。
tu = (10,)    # tuple，括号中虽然只有一个元素，但是元素后面有一个逗号，表示这是一个元组。
tu = ()    # tuple，这时空元组的表示方法，括号中什么都没有。

字典

.fromkeys() 方法

.fromkeys() 方法用来批量创建键值对，此方法需要两个参数，参数 1 是一个可迭代对象，将会迭代添加到字典中成为键，参数 2 是这些键共用的值：

dic = {'key': 1, 'key1': 2}
dic1 = dic.fromkeys('abc', 12)
print(dic,dic1)

输出的结果为：

{'key': 1, 'key1': 2} {'a': 12, 'b': 12, 'c': 12}

这里需要注意的是，.fromkeys() 方法并不是修改字典的方法，而是会创建一个新字典并返回。

另外一个需要注意的是，如果参数 2 是可变数据，所有的值会共用这个数据：

l = []
dic = dict().fromkeys('abc', l)
l.append(2)
print(l, dic)

输出的结果为：

[2] {'a': [2], 'b': [2], 'c': [2]}

类型转换

tuple(list)
list(tuple)

set(list)
list(set)

set(tuple)
tuple(set)

int(str)  # 字符串中必须全部都是阿拉伯数字
str(int)

s1 = "".join('列表','元组')    # 将列表转换成字符串   ****
s.split(":")              # 将字符串转化成列表   ****

str(dict)
str(list)
str(tuple)
str(int)
str(set)
str(bool)

基础数据类型总结

原文地址：https://www.cnblogs.com/shuoliuchina/p/12427340.html