python学习 --- 数据类型

目录

python内建数据类型

分类 python类型
Text Type str
Numeric Types int, float, complex
Sequence Types list, tuple, range
Mapping Type dict
Set Types set, frozenset
Boolean Type bool
Binary Types bytes, bytearray, memoryview

布尔类型

True/False

print(bool("")) #False
print(bool(0)) #False

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数), 如 1 + 2j、 1.1 + 2.2j

字符串

python字符串可以简单的理解为一个不可变的字符数组，因此它也支持大部分的数组操作：如截取，in/not in判断，以及加号和乘号运算符等

表示

  • python中单引号和双引号使用完全相同，使用三引号可以指定一个多行字符串。
  • 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print( r'\n' )
print( R'\n' )

转义

>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!
>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!

截取

截取遵循“左开右闭”原则

var1 = 'Hello World!'
var2 = "Runoob" 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

格式化

C sprintf形式

%[(name)][flags][width].[precision] typecode
(name)：即变量的名称，当使用这种形式时，%后面的参数根据名字而不是位置来匹配，因此需要是dictionary类型，而不再是元组
flags：可以有+,-,' '或0。+表示右对齐。-表示左对齐。' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示左侧使用0填充。
width：表示显示的最小宽度
precision：表示小数点后精度
typecode：

typecode 说明
%s 格式化字符串
%d 格式化整数
%f 格式化浮点数
%e 用科学计数法格式化浮点数 
name="james"
number=35.569
print('Hey %(name)s, there is a %(num)+5.2f number!' % {"name": name, "num": number})
print('Hey %s, there is a %+5.2f number!' % (name,number))
#Hey james, there is a +35.57 number!

format()方法

大括号表示要替换的位置，如果大括号中的内容为数字表示按位置匹配，如果是字符串则表示按变量名匹配。
格式规则：参数序号或参数名:<填充><对齐><宽度><,><.精度><类型>

  • 填充：默认采用空格
  • 对齐：分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐
  • 宽度：输出字符最小宽度
  • ,：千位分隔符
  • <.精度>：对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。
  • <类型>：b-二进制，c-Unicode字符，d-十进制，o-八进制，x-十六进制，X-十六进制（大写），e/E-浮点科学计数形式，f-浮点，%-浮点百分数形式
# 格式化，format方法
print("Hey {}, there is a {} number!".format(name, number))
print("Hey {0}, there is a {1} number!".format(name, number))
print("Hey {name}, there is a {number} number!".format(**{"name": name, "number": number}))

print("Hey {0}, there is a {1:0>8,.2f} number!".format(name, number))
print("Hey {name}, there is a {number:0>8,.2f} number!".format(**{"name": name, "number": number}))
#Hey james, there is a 1,035.57 number!

f-string：python3.6以后

格式仍遵循：<填充><对齐><宽度><,><.精度><类型>，但有所拓展。

  • 对齐 align："<" | ">" | "=" | "^"
  • 符号 sign ：这个仅仅对数值有效 "+" | "-" | " "
  • 宽度 width：是一个整数数值，表示多少宽度
  • 千位分隔符：表示千分位的分隔符号，可以是 "_" | ","
  • 精度 precision ： .数字
  • 类型 type："b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
print(f'Hey {name}, there is a {number:0>8,.2f} number!')

内建函数

Python - String Methods

大小写转换

hw = "hello, world!"
assert "Hello, world!" == hw.capitalize()
assert "Hello, World!" == hw.title()
assert "hello, world!" == hw.lower()
assert "HELLO, WORLD!" == hw.upper()
assert "HELLO, WORLD!" == hw.swapcase()

断言类函数：is*/startswith()/endswith()

  • isalpha()/isalnum()/isdecimal()/isdigit()/isnumeric()/isidentifier()/isprintable()/isspace()
  • istitle()/isupper()/islower()

python中str函数isdigit、isdecimal、isnumeric的区别

查找子串：count,find,index

  • count()：返回匹配的子串个数
  • find()/rfind()：返回第一个匹配成功的index，没匹配到返回-1；rfind()表示从右向左查找，下同
  • index()/rindex()：返回第一个匹配成功的index，没匹配抛出异常

translate()/maketrans()

这两个函数通常配合使用：maketrans生成translate用的字典，maketrans的前两个参数字符数必须相等，否则会报错；第三个参数可选，表示要删除的字符

txt = "Good night Sam!"
x = "mSa"
y = "eJo"
z = "odnght"
mytable = txt.maketrans(x, y, z)
print(mytable)
print(txt.translate(mytable))
#{109: 101, 83: 74, 97: 111, 111: None, 100: None, 110: None, 103: None, 104: None, 116: None}
# G i Joe!

replace(oldvalue, newvalue, count)：替换子串

第三个参数可选，表示替换几次，默认替换所有

分割和分区：split(separator, maxsplit)/splitlines()/partition()

  • split()/rsplit()是根据分隔符分割字符串，返回一个list。第一个参数是分隔符，默认为空格；第二个参数可选，表示最多做几次分割：1次切割分为2组，2次分为3组，以此类推
txt = "apple, banana, cherry"
x = txt.rsplit(", ", 1)
print(x)
#['apple, banana', 'cherry']
  • splitlines(keeplinebreaks)：是否保留换行符，可选参数，默认为False
  • partition()/partition()则是分区，返回一个包含3个元素的元组，分别是分隔符前面的部分，分隔符自身和它后面的部分；如果分隔符不存在，则后两个元素为空串
txt = "I could eat bananas all day"
x = txt.partition("apples")
print(x)
#('I could eat ', 'bananas', ' all day')

拼接：join()

join(iterable)：输入参数时一个可迭代类型，返回一个字符串

myTuple = ("John", "Peter", "Vicky")
x = "#".join(myTuple)
print(x) # John#Peter#Vicky

对齐和裁剪

  • ljust()/rjust()/center()：对齐，传入两个参数：第一个参数为长度，必填；第二个参数为填充的字符，选填，默认为空格
  • lstrip()/rstrip()/strip()：裁剪，传入字符串序列，默认为空格
str = "123abcrunoob321" 
print (str.strip( '12' )) # 字符序列为 12
  • zfill(width)：返回指定长度的字符串，并在左边填充0

list

  • list中的元素可以是不同的类型，也支持嵌套
  • list是可变的
  • list支持切片和负数索引
  • list支持in/not in
  • 使用+运算符可以合并两个列表

类型和长度

mylist = ["apple", "banana", "cherry"]
print(type(mylist)) # <class 'list'>
print(len(mylist)) # 3

修改元素

  • 使用索引修改元素，当索引的位置超出范围时会抛出异常
  • 可以使用range改变多个元素，原则也是前开后闭
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)
# ['apple', 'blackcurrant', 'watermelon', 'orange', 'kiwi', 'mango']

添加元素

  • list.append(elmnt)：在末尾添加元素
  • list.insert(pos, elmnt)：在指定位置插入元素
  • list.extend(iterable)：传入一个可迭代对象，把该对象的每个元素都加入列表末尾
thislist = ["apple", "banana", "cherry"]
tropical = "mango"
thislist.extend(tropical) #字符串会被认为是一个可迭代对象
print(thislist)
# ['apple', 'banana', 'cherry', 'm', 'a', 'n', 'g', 'o']

删除元素

  • list.remove(obj)：删除第一个obj匹配的元素
  • list.pop([index=-1])：按索引移除元素，返回被删除的元素；默认的index为-1，即删除最后一个元素
  • del：既可以删除整个list，也可以删除list中的某个元素；del整个list后，list的定义也不复存在
  • list.clear()：清空列表，list定义仍存在
thislist = ["apple", "banana", "cherry","pear"]

del thislist[2]
print(thislist)

thislist.remove('banana')
print(thislist)

thislist.pop()
print(thislist)

thislist.clear()
print(thislist)

del thislist
print(thislist) #此处会抛出异常，因为thislist的定义已经不复存在了

遍历列表

  • for in
thislist = ["apple", "banana", "cherry"]
for x in thislist:
  print(x)
  • 使用index
thislist = ["apple", "banana", "cherry"]
for i in range(len(thislist)):
  print(thislist[i])
  • 使用while
thislist = ["apple", "banana", "cherry"]
i = 0
while i < len(thislist):
  print(thislist[i])
  i = i + 1

列表推导

使用列表推导可以快速生成新的列表

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x for x in fruits if "a" in x]
print(newlist)
# ['apple', 'banana', 'mango']

排序

  • sorted(iterable, key=key, reverse=True|False)：返回一个新的排序后的列表
  • list.sort(reverse=True|False, key=myFunc)：对原列表进行排序，会改变原列表

倒序

  • reversed(sequence)返回一个倒序的迭代器
  • list.reversed()会对原数组进行倒序
alph = ["a", "b", "c", "d"]
ralph = reversed(alph)
print(list(ralph)) #['d', 'c', 'b', 'a']
print(alph) #['a', 'b', 'c', 'd']
alph.reverse()
print(alph) #['d', 'c', 'b', 'a']

复制

  • 使用built-in的copy()方法
thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)
  • 使用list()构造函数
thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

查找

  • count(value)：返回value在列表中出现的次数
  • index(value)：返回value第一次在列表中匹配的index，若不存在则抛出异常

tuple

  • tuple是一种特殊的不可变的列表，因此除了对元素进行增删改的操作，其他操作如切片等在tuple上都试用。

unpack：拆包

可以一次性给tuple中的多个变量赋值，并使用星号表示匹配其余的值

fruits = ("apple", "mango", "papaya", "pineapple", "cherry")
(green, *tropic, red) = fruits
print(green)
print(tropic) # ['mango', 'papaya', 'pineapple']
print(red)

dictionary

  • dictionary也就是map，用于存储键值对，它是无序的并且不允许键重复

访问

  • 使用方括号或get()访问字典
thisdict = {  "brand": "Ford",  "model": "Mustang",  "year": 1964}
x = thisdict["model"]
  • keys()/values()/items()：返回字典中所有的键/值/键值对，返回的对象相当于字典的一个view，当字典中的元素发生变化时，它也会跟着变化

添加和修改元素

  • 使用方括号修改
  • update(iterable)：可以一次更新多个值，也可以添加不存在的值
car = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
car.update({"color": "White","brand":"BMW","size":"large"})
print(car)
# {'brand': 'BMW', 'model': 'Mustang', 'year': 1964, 'color': 'White', 'size': 'large'}

删除

  • pop(key)：删除指定key的元素
  • popitem(）：删除最后插入的元素（3.7以前为随机删除一个元素）
  • del：删除整个字典或字典中的某个元素
  • clear()：清空字典，但字典的定义仍在

遍历

# 按key遍历
for x in thisdict:
  print(x)
# 按键值对遍历
for x, y in thisdict.items():
  print(x, y)
# 按值遍历
for x in thisdict.values():
  print(x)

复制

和list类似，可以使用dict.copy()或内建函数dict()

其他方法

fromkeys(keys, value)

第二个参数可选

x = ('key1', 'key2', 'key3')
y = 0
thisdict = dict.fromkeys(x, y)
print(thisdict)
# {'key1': 0, 'key2': 0, 'key3': 0}

setdefault(keyname, value)

非常有用的简便操作，返回key对应的值：

  • 如果key存在，则相当于get()，value不起作用
  • 如果key不存在，则插入key和value
car = {  "brand": "Ford",  "model": "Mustang",  "year": 1964}
x = car.setdefault("model", "Bronco")
print(x) #Mustang

set

  • set可以理解为没有value的dictionary，它是无序的且不允许重复
  • set中的元素可以是不同的类型
thisset = {"apple", "banana", "cherry", "apple"}

添加元素

  • set.add(elmnt)：添加单个元素
  • set.update(iterable)：批量添加元素

删除元素

  • remove(elmnt)/discard(elmnt)：元素不存在时，remove()会抛出异常，discard()则不会
  • pop()：随机删除一个元素
  • clear()：清空set
  • del关键字：删除set变量

集合运算

并集

  • set.union(set1, set2...)：多个set的并集，返回一个全新的set
  • set.update(iterable)：update实际是计算两个集合的并集，结果体现在原set中

交集

  • set.intersection(set1, set2 ... etc)：计算多个set的交集，返回一个全新的set
  • set.intersection_update(set1, set2 ... etc)：计算多个set的交集，并把结果更新到原set中
  • set.isdisjoint(set)：当两个集合没有相同元素时，返回True

差集和symmetric difference

  • 差集：使用减号来计算
  • set.symmetric_difference(set)/set.symmetric_difference_update(set)：保留两个集合中所有不同的元素
s1 = {"a", "b", "c", "d"}
s2 = {"c", "d", "e", "f"}
print(s1 - s2) #{'b', 'a'}
print(s1.symmetric_difference(s2)) #{'a', 'b', 'f', 'e'}

子集

  • set.issuperset(set)：判断集合是否为传入集合的超集
  • set.issubset(set)：判断集合是否为传入集合的子集
posted @ 2020-12-02 20:16  郑晓悦  阅读(89)  评论(0)    收藏  举报