Python 自学二——类型

基本类型

数字

  1. 整数:十进制-21,八进制-025,十六进制-0x15
  2. 浮点数:1.65,21.0,21.,.21,2.1E1
  3. 复数:1+1j

布尔

两个值:True,False。

0、0.0、‘’ 都认为是 False,其它是 True。

字符串

字符串是不可变的,它不能被更改。

字面量

  • 使用 ''"" 括起来的一系列字符。 s = 'abc' # 'abc' s = "abc" # 'abc' s = 'a"b"c' # 'a"b"c' s = "a'b'c" # "a'b'c" s = 'a\'b\'c' # "a'b'c" s = "a\"b\"c" # 'a"b"c'
  • 忽略转义符的原始字符串 在字符串引号前面加 r。 print(r'a\'b\'c') # a\'b\'c
  • 多行字符串 三个单引号或三个双引号原样输出。 print('''Dear Alice, Eve's cat has \' been arrested \t for catnapp\ning, cat burglary, and extortion. Sincerely, Bob''') 输出 Dear Alice, Eve's cat has ' been arrested for catnapp ing, cat burglary, and extortion. Sincerely, Bob 空号,缩进全都原样保留。转义符生效了。 多行字符串可当做多行注释来使用。

操作

  • 拼接重复 ‘Ab' + "cd" # 'Abcd',+ 表示字符串拼接 'ab' * 3 # 'ababab',* 表示字符串复制,只能用于字符串和整数 3 * 'ab' # 和上式等价
  • 下标 str = 'hello world' char1 = str[2] # 下标是 2,说明是前向索引,对应的字符应该是 l char2 = str[-1] # 下标是 -1,说明是后向索引,后向就是从 -1 开始,所以对应的字符是 d n = 4 char3 = str[n-3] # 下标也可以是一个赋值 int 型的变量
  • 取子串 s = "Monty Python" print(s[0:4]) # 输出 Mont print(s[6:20]) # 第二个已经超出字符串长度,直接取到最后,输出 Python print(s[:2]) # 省略第一个数字,默认认为从 0 开始,所以输出 Mo print(s[8:]) # 省略第二个数字,默认认为一直取到最后,输出 thon print(s[:]) # 两个数字都省略了,相当于从 0 取到尾,输出 Monty Pyton print(s[6:20:2]) # 步长为 2,输出 Pto print(s[10:2:-2]) # 输出 otPy # 特殊的,[::-1] 表示去逆串,如 print(s[::-1]) # 输出 nohtyP ytnoM
  • in/not in 'Hello' in 'Hello World' # True 'Hello' in 'Hello' # True 'HELLO' in 'Hello World' # False '' in 'spam' # True
  • 寻找子串首次出现的位置 find() fruit = "banana" pos = fruit.find('na') # 寻找子串 na 首次出现的位置 print(pos) # 2 a = fruit.find('a', pos) # 寻找 pos 位置之后的第一个 a,即 2 位置的后面的 a print(a) # 3 aa = fruit.find('aa') # 如果找不到,返回 -1 print(aa) # -1
  • 替换 greet = "Hello Bob" nstr = greet.replace("Bob","Jane") print(nstr) # Hello Jane # 先查找第一个参数指定的所有字符串,然后用第二个参数替换 nstr = greet.replace('o','X') print(nstr) # HellX BXb
  • 长度 len >>> len('ab c') # 4
  • 循环 fruit = 'banana' index = 0 while index < len(fruit): letter = fruit[index] print(letter) index = index + 1 # 与 while 循环效果相同 for letter in fruit: print(letter)
  • 大小写转换 greet = "Hello Bob" low = greet.lower() # 字符串全部转为小写并且返回新字符串 print(low) # 输出 hello bob print(greet.upper()) # 字符串全部转为大写,输出 HELLO BOB # title 方法将首字母变大写,其它字母变小写 print(low.title()) # 输出 Hello Bob islower(),isupper() 为 True 是字符串不为空,且全部小写或大写。 print(greet.islower()) # False print(low.islower()) # True print(low.isupper()) # False
  • isX 除了 islower() 和 isupper(),还有几个字符串方法,它们的名字以 is 开始。这些方法返回一个布尔值,描述了字符串的特点。
    • isalpha() 返回 True,如果字符串只包含字母,并且非空
    • isalnum() 返回 True,如果字符串只包含字母和数字,并且非空
    • isdecimal() 返回 True,如果字符串只包含数字字符,并且非空
    • isspace() 返回 True,如果字符串只包含空格、制表符和换行,并且非空
    • istitle() 返回 True,如果字符串仅包含以大写字母开头、后面都是小写字母的单词
  • startswith()/endswith() print('Hello world!'.startswith('Hello')) # True print('Hello world!'.endswith('world!')) # True print('Hello world!'.endswith('wor')) # False
  • join()/split()
    • join 参数是字符串列表,返回连接后的字符串,在一个字符串上调用,这个字符串表示分隔符
    • split 分割字符串成列表,不传参数默认以空白字符(空格,制表符,换行符)来分割,如果传参数按参数来分

    ', '.join(['cats', 'rats', 'bats']) # 以 `, ` 分隔 'cats, rats, bats' s = 'cat rat, bat, dot' print(s.split()) # ['cat', 'rat,', 'bat,', 'dot'] print(s.split(',')) # ['cat rat', ' bat', ' dot']

  • 对齐文本 通过插入空格来对齐文本,方法的第一个参数是一个整数长度,用于对齐字符串。若有第二个参数,可用于指定一个填充字符以取代空格。
    • rjust() 右对齐
    • ljust() 左对齐
    • center() 居中对齐。

    >>> 'Hello'.rjust(10) ' Hello' >>> 'Hello'.rjust(20) ' Hello' >>> 'Hello World'.rjust(20) ' Hello World' >>> 'Hello'.ljust(10) 'Hello ' >>> 'Hello'.rjust(20, '*') '***************Hello' >>> 'Hello'.center(20) ' Hello ' >>> 'Hello'.center(20, '=') '=======Hello========'

  • 删除空白字符
    • strip() 删除左右两边的空白字符(空格、制表符和换行)
    • rstrip() 删除右边的空白字符
    • lstrip() 删除左边的空白字符

    >>> spam = ' Hello World ' >>> spam.strip() 'Hello World' >>> spam.rstrip() ' Hello World' >>> spam.lstrip() 'Hello World ' 可以通过一个参数指定哪些字符可以删除,字符出现的顺序无所谓,只要能完全匹配上。 >>> spam.strip('He') # 两侧没有 'He' ' Hello World ' >>> spam.strip(' He') # 左边匹配上了 'llo World' >>> spam.strip('He ') # 左边匹配上了,顺序不重要 'llo World' >>> spam.strip('e H') 'llo World'

  • 复制粘贴 引入 pyperclip 模块,里面有 copy() 和 paste() 函数,可以向计算机的剪贴板发送文本,或从它接收文本。 pyperclip 模块不是 Python 自带的,需要另外安装。终端中切换到 /Library/Frameworks/Python.framework/Versions/3.7/bin/pip3,执行 sudo pip3 install pyperclip import pyperclip # 作用是将 'Hello world!' 复制到系统剪贴板 pyperclip.copy('Hello world!') # 作用是粘贴系统剪贴板里的内容 s = pyperclip.paste()

类型转换

  1. 强制转换 str(29) # '29' str(3.14) # '3.14' int('-99') # -99 int('1.25') # 报错 int(1.25) # 1 int(1.99) # 1 float('3.14') # 3.14 float('-1') # -1.0 bool(123):True bool(0):False
  2. 自动转换 转换顺序 bool -> int -> float -> complex

引用类型

列表

List 可以是空的,可以存放任何类型的变量,包括 List 本身,如 [1, 24, 76]['red', 'yellow', 'blue']['red', 24, 98.6][ 1, [5, 6], 7][]

list() 函数创建一个空列表。

  • 元组和字符串的转换 list(('cat', 'dog', 5)) # 元组转列表 ['cat', 'dog', 5] list('hello') # 字符串转列表 ['h', 'e', 'l', 'l', 'o']
  • 下标操作 friends = ['Joseph', 'Glenn', 'Sally' ] print(friends[1]) # 输出 Glenn print(friends[-1]) # 反向索引最后一个就是 -1,所以输出 Sally friends[2] = 'Alex' # 可以更改内容 list = [1, [5, 6], 7] print(list[1][0]) # 输出 5,多重下标
  • 取出子列表 t = [9, 41, 12, 3, 74, 15] t[1:3] # 是 [41,12],含头不含尾 t[:4] # 是 [9, 41, 12, 3] t[3:] # 是 [3, 74, 15] t[:] # 是 [9, 41, 12, 3, 74, 15]
  • 多重赋值 cat = ['fat', 'black', 'loud'] size, color, disposition = cat size 被赋值为 'fat',color 被赋值为 'black',disposition 被赋值为 'loud'。和元组类似。 变量个数必须和列表元素个数一致。
  • 拼接和重复 list = [3, 'H'] print(list + [2.3]) # 输出 [3, 'H', 2.3] print(list * 3) # 输出 [3, 'H', 3, 'H', 3, 'H'] list += ['a','b'] # 拼接后并且赋给自己 print(list)
  • in/not in list = [1,2,3] if 1 in [1,2,3]: print('list has 1') 'Glenn' not in ['Joseph', 'Glenn', 'Sally'] # False
  • 取下标 index() >>> friends = ['Joseph', 'Glenn', 'Sally', 'Glenn'] >>> friends.index('Joseph') 0 >>> friends.index('Glenn') 1 >>> friends.index('Ha') Traceback (most recent call last): File "<pyshell#99>", line 1, in <module> friends.index('Ha') ValueError: 'Ha' is not in list 取出下标,如果有重复的值,取第一次出现的下标,如果不存在,报错。也可以用于判断元素是否存在于列表里。
  • 返回列表 range()
    • range(a,b,k) 表示初值是 a,终值是 b,步长是 k,取值不能超过 b。
    • range(a,b) 默认步长为 1,取值就是 a,a+1,...,b-1。
    • range(b) 默认初值为 0,步长为 1,唯一的这个数字表示终值。

    for i in range(3,0,-1): print(i) # 输出 3,2,1 直接将 range 结果转为列表, >>> list(range(1,5)) [1, 2, 3, 4]

  • 长度 len() friends = ['Joseph', 'Glenn', 'Sally'] print(len(friends)) # 3 # for 循环中,第一种遍历方法 for friend in friends : print('Happy New Year:', friend) # for 循环中,第二种遍历方法,这样可以知道当前处于哪个位置 for i in range(len(friends)): # 算出长度,然后用 range 返回一个列表 friend = friends[i] print('Happy New Year:', friend)
  • 添加
    • append 尾部追加一个
    • extend 尾部追加一个列表
    • insert 指定下标插入

    list = ['a', 4.2] list.append(2) # 末尾添加 2 print(list) # ['a', 4.2, 2] list.insert(1, True) # 指定位置插入 True print(list) # ['a', True, 4.2, 2] list.extend(['xyz','abc']) # 追加一个列表 print(list) # ['a', True, 4.2, 2, 'xyz', 'abc']

  • 删除
    • pop 不传参数是末尾,传参数是指定位置删除并且返回被删除的值
    • remove 删除指定元素,如果有多个重复元素,删除第一次出现的值
    • del 语句删除指定位置的元素

    list = [1, 2, 3, 4, 5] list.pop() # 默认删除最后一个并返回 5,list 也变成了 [1, 2, 3, 4] list.pop(0) # 删除第 0 个位置并返回 1,list 变成 [2, 3, 4] list.remove(2) # 删除 2 这个元素,2 不是下标,list 变成了 [3, 4] del list[1] # 删除了 4,list 变成 [3]

  • 排序 sort() 参数 reverse 用于控制是否逆序,不能对既有字符串又有数字的列表排序。 friends = [ 'Joseph', 'Glenn', 'Sally' ] friends.sort() # 调用列表的方法排序后,列表本身内容就变了 print(friends) # 输出 ['Glenn', 'Joseph', 'Sally'] list = [3, 5, 2, 1] print(sorted(list)) # 将列表作为参数,排序后输出的是一个新的列表,list 本身并没有发生变化 print(list) # 输出 [3, 5, 2, 1] list.sort(reverse=True) # 逆序排序 print(list) # [5, 3, 2, 1] 对字符串排序,使用 ASCII 字符顺序,而不是字典顺序,因此小写字母在大写字母后面。如果要使用字典顺序,需要设 key 为 str.lower,sort 方法会将所有字母当成小写。 spam = ['A', 'a', 'X', 'x'] spam.sort() print(spam) # ['A', 'X', 'a', 'x'] spam.sort(key=str.lower) # 因为都当成小写,所以原列表大写字母在前面,排序后大写字母也在前面 print(spam) # ['A', 'a', 'X', 'x'] spam = ['a', 'x', 'A', 'X'] spam.sort(key=str.lower) # 原列表大写字母在后面,排序后大写字母也在后面 print(spam) # ['a', 'A', 'x', 'X']
  • 逆序 reverse() list = [1, 2, 3, 4, 5] list.reverse() print list # [5, 4, 3, 2, 1]
  • 数学计算 nums = [3, 41, 12, 9, 74, 15] print(max(nums)) # 74 print(min(nums)) # 3 print(sum(nums)) # 154 print(sum(nums)//len(nums)) # 25
  • 列表解析或推导 一种由原列表创建新列表的简洁方法,格式是 [表达式 for 语句] # x 是从 0 到 9,前面是一个关于 x 的表达式,这个表达式组成的值就是新列表的元素 # 所以 lst 是 [1, 4, 9, 16, 25, 36, 49, 64,81] lst = [x**2 for x in range(1,10)] print(lst) students = [['Zhang', 80], ['Qin', 79], ['Li', 100]] # scores 的元素是每个 student 里下标为 1 的那些值 # 所以 scores 是 [80, 79, 100] scores = [student[1] for student in students] print(scores)
  • 复制 引用类型在函数调用中默认传的是引用,若不想传引用而是传递一个副本,使用 copy 模块的 copy() 和 deepcopy() 方法 import copy spam = ['A', 'B', 'C', 'D'] # 一个列表 cheese = copy.copy(spam) # 副本 cheese[1] = 42 # 修改副本不会影响原来的 spam print(spam) # ['A', 'B', 'C', 'D'] print(cheese) # ['A', 42, 'C', 'D'] 如果要复制的列表中包含了列表,那就使用 copy.deepcopy() 函数来代替,deepcopy() 函数将同时复制它们内部的列表。

集合 Set

与列表相比,集合里的元素是无序的,不重复的。许多方法和列表一样。

x = set() # 创建一个集合
x.add(3) # 添加一个元素
print(x) # {3}
x.add('aa')
x.add('aa') # 如果已经存在,由于集合不重复,结果只有一个 aa
print(x) # {3, 'aa'}
x.remove(3) # 删除一个元素
print(x) # {'aa'}

字典

字典 Dictionary 存储的是键值对,数据结构和 Java 中的 Map 一样。用 {} 表示。

dict() 函数创建一个空字典。

字典的键必须是不可变的且无重复,所以不能用列表作为键,因为它是可变的。字典的值可以是列表,也可以是字典。

字典无序,键值对输入的顺序并不重要。

  • 下标操作 purse = dict() # 开始向字典中添加键值对 purse['money'] = 12 purse['candy'] = 3 purse['tissues'] = 75 print(purse) # {'money': 12, 'candy': 3, 'tissues': 75} # 根据键取出值 print(purse['candy']) # 3 # 插入新的值,键已存在,新值代替旧值 purse['candy'] = purse['candy'] + 2 print(purse) # {'money': 12, 'candy': 5, 'tissues': 75}
  • get() 它有两个参数:要取得其值的键,以及该键不存在时返回的备用值。 b = {'cash':30, 'money': 12} print(b.get('money', 10)) # 12 print(b.get('money2', 10)) # 10
  • setdefault() 如果不存在指定的键,就用默认值赋值,如果已经存在,什么都不做。它可以保证字典里某个键存在。 方法有返回值,返回这个键对应的值。 spam.setdefault('color', 'black') # 相当于下面的简写 if 'color' not in spam: spam['color'] = 'black' message = 'It was a bright cold day in April, and the clocks were striking thirteen.' count = {} for character in message: count.setdefault(character, 0) # 如果还不存在,就设为 0 count[character] = count[character] + 1 print(count)
  • keys()、values()、items() 它们将返回类似列表的值,分别对应于字典的键、值和键值对。这些方法返回的值不是真正的列表,不能被修改,没有 append() 等方法,但这些数据类型(分别是 dict_keys、dict_values 和 dict_items)可以用于 for 循环。 可以将返回结果作为 list() 的参数构造一个列表。 spam = {'color': 'red', 'age': 42} for k in spam.keys(): print(k, end=' ') # color age print() for k in spam: # 直接用字典名,就相当于是遍历键 print(k, end=' ') # color age print() list = list(spam.keys()) # 从返回的键构建一个列表 print(list) # ['color', 'age'] for v in spam.values(): print(v, end=' ') # red 42 print() for item in spam.items(): print(item, end=' ') # ('color', 'red') ('age', 42) 返回的是元组 print() for k, v in spam.items(): # 利用多重赋值将键值对分别赋值 print('k=' + k + ',v=' + str(v), end = ' ') # k=color,v=red k=age,v=42
  • in/not in c= {} # 一个空的字典 print('money' in c.keys()) # False b = {'cash':30, 'money': 12} # 创建一个字典 print('money' in b.keys()) # True print('money' in b) # 和上一句等价 print('money' not in b) # False in/not in 后面直接跟字典名,相当于判断是否在键里,即 in b 等价于 in b.keys()
  • 长度 len() b = {'cash':30, 'money': 12} print(len(b)) # 输出 2
  • 删除
    • pop 根据键名删除并返回值
    • del 语句直接删除

    b = {'cash':30, 'money': 12} print(b.pop('cash')) # 输出 30 del b['money']

漂亮打印

如果程序中导入 pprint 模块,就可以使用 pprint()和 pformat()函数,它们将“漂亮打印”一个字典的字。

import pprint
message = 'It was a bright cold day in April, and the clocks were striking thirteen.'

count = {}
for character in message:
    count.setdefault(character, 0)
    count[character] = count[character] + 1

print(count)
pprint.pprint(count)

第一种打印结果

{'I': 1, 't': 6, ' ': 13, 'w': 2, 'a': 4, 's': 3, 'b': 1, 'r': 5, 'i': 6, 'g': 2, 'h': 3, 'c': 3, 'o': 2, 'l': 3, 'd': 3, 'y': 1, 'n': 4, 'A': 1, 'p': 1, ',': 1, 'e': 5, 'k': 2, '.': 1}

第二种打印结果,键排过序,而且做了对齐。

{' ': 13,
 ',': 1,
 '.': 1,
 'A': 1,
 'I': 1,
 'a': 4,
 'b': 1,
 'c': 3,
 'd': 3,
 'e': 5,
 'g': 2,
 'h': 3,
 'i': 6,
 'k': 2,
 'l': 3,
 'n': 4,
 'o': 2,
 'p': 1,
 'r': 5,
 's': 3,
 't': 6,
 'w': 2,
 'y': 1}

pprint.pprint(count)print(pprint.pformat(count)) 等价。

元组

用圆括号 () 表示,元组就相当于不可变列表。列表中除了可改变列表内容的方法外,其它方法均适用于元组。

  • 声明创建 # 元组是通过逗号 ',' 来定义的,下面两种方法都是生成元组 (1, 'a', 3.14, True) my_tuple = 1, 'a', 3.14, True my_tuple = (1, 'a', 3.14, True) 如果元组中只有一个值,要在括号内该值的后面跟上一个逗号。否则,Python 将认为只是在一个普通括号内输入了一个值。逗号表明这是一个元组。 >>> type(('hello',)) <class 'tuple'> >>> type(('hello')) <class 'str'>
  • 赋值 (x,y) = (4, 'fred') x,y,z = (4, 'fred', True) 可以直接赋值,一一对应。
  • 关系运算: 关系运算规则和其它一样,两个元组根据对应位置的大小来比 (0, 1, 2) < (5, 1, 2) # True (0, 1, 2000000) < (0, 3, 4) # True ( 'Jones', 'Sally' ) < ('Jones', 'Fred') # False ( 'Jones', 'Sally') > ('Adams', 'Sam') # True
  • 将列表转成元组 tuple(['cat', 'dog', 5]) # 列表转元组 ('cat', 'dog', 5)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏从流域到海域

Python yield关键字 和 Generator(生成器)

Generators functions allow you to declare a function that behaves like an itera...

274100
来自专栏软件开发 -- 分享 互助 成长

C++ STL之set的基本操作

set是集合,虽然也存在键值和实值,不过两者根本就是同一个值,键值的设置完全就是为了满足红黑树的底层结构,set操作与map很像不过也有些不同。 1、 set迭...

36750
来自专栏大前端_Web

javascript中的for in 和 in运算符

版权声明:本文为吴孔云博客原创文章,转载请注明出处并带上链接,谢谢。 https://blog.csdn.net/wkyseo/articl...

13920
来自专栏Java学习123

Java反射教程(二)

369130
来自专栏互联网杂技

JavaScript 10分钟入门

简介 JavaScript是一门面向对象的动态语言,他一般用来处理以下任务: 1、修饰网页 生成HTML和CSS 生成动态HTML内容 生成一些特效 2、提供...

372100
来自专栏Pythonista

python内置函数大全

最近一直在看python的document,打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Cons...

23710
来自专栏coder修行路

go基础之--函数和map

在整理函数之前先整理一下关于指针 指针 普通类型变量存的就是值,也叫值类型。指针类型存的是地址,即指针的值是一个变量的地址。 一个指针指示值所保存的位置,不是所...

30170
来自专栏Python爬虫实战

Python指南:组合数据类型

Python提供了5中内置的序列类型:bytearray、bytes、list、str与tuple,序列类型支持成员关系操作符(in)、大小计算函数(len()...

17010
来自专栏深度学习思考者

C++常见问题(二)——虚函数、类与结构、引用与值传递

一 文件输入输出的方式 C++定义了ifsteam、ofstream和fstream 3种类型以用来支持文件的输入输出。 二 异常 异常就是程序运行时出...

19760
来自专栏前端真相

JavaScript基础(3)

19850

扫码关注云+社区

领取腾讯云代金券