【python】一：基础学习-数据类型及相关方法

数据类型

• 数字：

  • int：整数
  • float：浮点数（双精度的）

• 布尔：

  • bool：(False，True)、（0,1）

• 序列（有序）

  • 字符串：str

  • 列表：list
    [1,2,3,4,5,6]

  >>> type([1,2,3])
  <class 'list'>
  1
  2

  • 元祖：tuple
    （1,2,3,4）
    以下情况：元祖只有一个元素，此时括号表示数学运算的括号，即

    >>> type((1))
    <class 'int'>
    1
    2

    如果想表示一个元素的元祖，那么：

    >>> type((1,))
    <class 'tuple'>
    1
    2

    空元祖

    >>> type(())
    <class 'tuple'>
    1
    2

• 集合：set

  • 无序

  • 不重复

  • 不能切片（不能索引）

  • 差集 ： -

  • 交集 ：&

  • 并集： |

  • 空集：set()

    >>> {1,2,3,4,5} - {3,4}
    {1, 2, 5}
    >>> {1,2,3,4,5} & {3,4}
    {3, 4}
    >>> {1,2,3,4,5} | {3,4}
    {1, 2, 3, 4, 5}
    >>> len(set())
    0
    >>> type(set())
    <class 'set'>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

• 字典：dict

  • key和value

  • key：必须不可变

  • value：str，int，float，list，set，dict

  • 集合类型

  • 不能有重复的key，有重复后一个覆盖前一个

  • 空字典：{}

    >>> {'k':1,'b':2,2:3}['b']
    2
    >>> {'k':1,'b':2,2:3}[2]
    3
    >>> {'k':1,'b':2,2:3,'dict':{'h':123}}['dict']
    {'h': 123}
    >>> {'k':1,'b':2,2:3,'k':123} // 重复的有，实际第一个k不存在
    {'k': 123, 'b': 2, 2: 3}
    1
    2
    3
    4
    5
    6
    7
    8

进制

二进制标示符：0b

八进制标示符：0o

十六进制标示符：0x

十六进制：123456789ABCDEF

运算符

• // ： 运算除法后取整数部分，即整除

  >>> 5//3
  1
  >>> 5//2
  2
  1
  2
  3
  4

• in：判断一个元素是否在另一个元素内
  判断一个元素不在另一个元素，则not in

  >>> "h" in "holle word"
  True
  >>> "b" in "holle word"
  False
  >>> 2 in [1,2,3]
  True
  >>> 5 in [1,2,3]
  False
  >>> 1 in (1,2,3)
  True
  >>> 2 in (1,3,4)
  False
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

方法

• type(n)：识别数据类型
• bin(n)：其他转二进制
• int(n): 其他进制转10进制，这里是int方法，不是数据类型，数字字符串转数字
• oct(n)：转八进制
• hex(n)：转十六进制
• len(n): 求长度，序列、集合都可以
• max(n)：求最大，序列、集合都可以
• min(n)：求最小，序列、集合都可以
• ord(n)：获取ascll码
• id(n)：获取内存地址

符号

• 三引号'''：三引号内可以换行输入字符串

• 反斜杠\：转义字符，有一下示例：

  >>> print('c:\www\nt\netWork')
  c:\www
  t
  etWork
  // \n被转义了
  // 以下两种等效
  // 1. 给\转义
  >>> print('c:\www\\nwt\\nqetWork')
  c:\www\nwt\nqetWork
  // 2. 字符串前加个r/R
  >>> print(r'c:\www\nwt\nqetWork')
  c:\www\nwt\nqetWork
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

转义字符

• \n 换行
• \r 回车
• \t 横向制表符
• …

序列运算

• 序列 * 数字 = 重复数字个的字符串
• 序列 +序列=序列

序列截取（切片）

• [n]：从头向后取第n个字符，0开始，负数从后向前数，1开始

  >>> 'holle word'[2]
  'l'
  1
  2

• [n1:n2]：截取从n1到n2之间的，不包括n2

  >>> 'holle word'[0:5] // 取前五个字符
  'holle'
  >>> 'holle word'[1:] // 取从1开始的后面的字符
  'olle word'
  >>> 'holle word'[-3:] // 取从倒数第三个开始的剩余字符
  'ord'
  >>> 'holle word'[:-3] // 从第0个开始到倒数第三个之间，不包含倒数第三个 === [0:-3]
  'holle w'
  >>> 'holle word'[-3:0] // 此类没有
  ''
  >>> 'holle word'[3:-2] // 从第3个开始到倒数第二个之间，不包含倒数第二个
  'le wo'
  >>> 'holle word'[3:30] // 30>字符串长度 === [3:]
  'le word'
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

• [n1:n2:n3]：截取从n1到n2之间的间隔n3的元素（不包括n2）

  >>> "holle word"[0:8:1]
  'holle wo'
  >>> "holle word"[0:8:2]
  'hlew'
  >>> "holle word"[0:8:3]
  'hlw'
  >>> "holle word"[0:8:4]
  'he'
  >>> "holle word"[0:8:5]
  'h '
  >>> "holle word"[1:8:5]
  'ow'
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

变量

• 区分大小写
• 不能使用关键字（保留字）
• 可以使用type，但不建议

运算符

• 算数运算符：+、-、*、/、//(相除取整)、%，**(指数运算)

• 赋值运算符：=、+=、-=、/=、%=、**=、//=

• 比较运算符：==、!=、>、<、>=、<=

• 逻辑运算符：and、or、not

• 成员运算符：in、not in

• 身份运算符：is、is not (比较两个变量的内存地址是否相等)

• 位运算符（把数字当做二进制进行计算）：& (按位与)、| (安位或)、^ (按位异或)、~ (按位取反)、<< (左移动)、>> (右移动)

• python没有自增与自减

• ==与is区别：==值是否相等，is比较两个变量的身份是否相等

  >>> a = 1
  >>> b = 1.0
  >>> a==b
  True
  >>> a is b
  False
  >>> 
  >>> id(a) 内存地址
  1491252288
  >>> id(b) 内存地址
  2343090002584
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

判断类型

• type() 加 ==，不推荐

• isinstance(val,type)

  • val：要判断的对象

  • type：类型（str，int，list…），可以是一个元祖，示例如下

    >>> a = 'iop'
    >>> isinstance(a,str)
    True
    >>> isinstance(a,int)
    False
    >>> isinstance(a,(str,int,list)) // 第二个参数是元祖，表示a是否是其中的一种类型
    True
    >>> isinstance(a,(int,list))
    False
    1
    2
    3
    4
    5
    6
    7
    8
    9

多常量赋值–序列解包

a = 1
b = 2
c = 3

a,b,c = 1,2,3 # a=1,b=2,c=3
# -------------------------
d = 1,2,3
a,b,c = d # a=1,b=2,c=3
# -------------------------
a=b=c=1 # a=1,b=1,c=1
# 解包时，接收值的变量数量要和解包的对象长度一样
1
2
3
4
5
6
7
8
9
10
11