一、变量和数据类型

目录

• 1. 变量
  • 1.1 定义
  • 1.2 分类
  • 1.3 变量命名
• 2. 数据类型
  • 2.1 数字
  • 2.2 布尔类型
  • 2.3 字符串
  • 2.4 列表
  • 2.5 元组
  • 2.6 集合
  • 2.7 字典

1. 变量

1.1 定义

变量是用来存储数据的量，变量名由字母、数字、下划线组成的，且不能以数字开头。此外，在编程的过程中，所有变量的命名都要做到见名知意。

1.2 分类

• 全局变量

  作用范围在全局的变量，例如：一个类中定义的类变量，类中所有的方法都可以使用该变量。

• 局部变量

  作用范围在局部的变量，例如：一个类中的方法定义的方法变量，该变量只能在该方法中使用，而不能给类中的其他方法使用。

1.3 变量命名

• 下划线命名法

  单词之间用下划线连接的命名方式，例如：auto_test。在Python中，一般默认函数名的命名方式采用下划线命名法。

• 驼峰命名法

  • 小驼峰命名法

    除首字母小写外之后的每个单词的首字母大写的命名方式，例如：autoTest。

  • 大驼峰命名法

    每个单词的首字母大写的命名方式，例如：AutoTest。一般默认类名的命名方式采用大驼峰命名法。

• 注意

  在变量命名时要避开使用关键字来作为变量名。

2. 数据类型

2.1 数字

• 整数

  int表示整数类型。

• 浮点数

  float表示浮点数类型。

• 注意

  int和float类型都是不可变的。

2.2 布尔类型

• 格式

  bool，布尔类型的值只有两个：True和False。

  print(bool(0))
  print(bool(3))
  print(bool(''))
  print(bool('it'))
  
  # 输出结果
  False
  True
  False
  True
  
  # 注意：所有的数字除0布尔值为False外，其他布尔值均为True；所有的字符串除空字符串''布尔值为False外，其他布尔值均为True。

2.3 字符串

• 格式

  str，由单引号'，双引号"，三引号'''或"""所包含的内容为字符串。字符串是不可变的。

• 字符串操作

  • 字符串的加法运算和乘法运算

    string1 = 'Hello'
    string2 = 'World!'
    # 加法运算
    string3 = string1 + ' ' + string2
    # 乘法运算
    string4 = string3 * 3
    print(string3)
    print(string4)
    
    # 输出结果
    Hello World!
    Hello World!Hello World!Hello World!

  • 字符串方法

    • 首字母大写、标题、小写、大写

    '''
    .capitalize
    .title
    .lower
    .upper
    '''
    
    string1 = 'my Favorite programming Language is python.'
    print(string1.capitalize())
    print(string1.title())
    print(string1.lower())
    print(string1.upper())
    
    # 输出结果
    My Favorite Programming Language Is Python.
    my favorite programming language is python.
    MY FAVORITE PROGRAMMING LANGUAGE IS PYTHON.

    • 判断是否为数字

    '''
    .isdecimal
    .isnumeric
    .isdigit
    '''
    
    string2 = ['1', '①', '一']
    for i in string2:
        print(i.isdecimal()) # 最常用
        print(i.isnumeric())
        print(i.isdigit())
        print('=='*5)
    
    # 输出结果
    True
    True
    True
    ==========
    False
    True
    True
    ==========
    False
    True
    False
    ==========
    

    • 切片

    string3 = '0123456789'
    print(string3[:])
    print(string3[:2])
    print(string3[2:])
    print(string3[1:5])
    print(string3[:-1])
    print(string3[0:4:2])
    
    # 输出结果
    0123456789
    01
    23456789
    1234
    012345678
    02
    
    # 注意：从前往后索引是从0开始的，从后往前索引是从-1开始的（即：最后一位元素的索引为-1）。srting3[参数1：参数2：参数3]，参数1是切片时索引的起始位置，参数2是结束位置（不包括参数2本身，即：参数1和参数2是可看作一个前闭后开的集合），参数3是步长（即：切片时每两个参数之间的间隔）。

    • 去空格

    '''
    .strip
    .lstrip
    .rstrip
    '''
    
    string4 = ' it is delicious. '
    print(string4.strip())
    print(string4.lstrip())
    print(string4.rstrip())
    
    # 输出结果
    it is delicious.
    it is delicious. 
     it is delicious.

    • 按指定字符切分字符串

    '''
    .split
    .partition
    .rpartition
    '''
    
    string5 = 'i=am=aaron'
    # split切分所有的指定字符，且切分之后该字符不存在，输出结果为列表类型。
    print(string5.split('='))
    # partition和rpartition切分遇到的第一个字符，且切分之后指定的字符还在(将字符串切分为三个部分)，输出结果为元组类型。
    print(string5.partition('='))
    print(string5.rpartition('='))
    
    # 输出结果
    ['i', 'am', 'aaron']
    ('i', '=', 'am=aaron')
    ('i=am', '=', 'aaron')

    • 按指定字符串连接列表中的元素

    '''
    .join
    '''
    
    string6 = '-'
    list1 = ['2019', '10', '28']
    print(string6.join(list1))
    
    # 输出结果
    2019-10-28

    • 计算指定字符在字符串中出现的次数

    '''
    .count
    '''
    
    string7 = 'Today*is*a*sunny*day.'
    print(string7.count('*'))
    
    # 输出结果
    4

    • 判断字符串的开始和结尾元素

    '''
    .startswith
    .endswith
    '''
    
    string8 = 'I am an number 9'
    print(string8.startswith('I'))
    print(string8.endswith('9'))
    
    # 输出结果
    True
    True

    • 查找指定字符

    '''
    .index
    .rindex
    .find
    .rfind
    '''
    
    string9 = 'pronunceation'
    print(string9.index('n'))
    print(string9.rindex('n'))
    print(string9.find('x'))
    print(string9.find('o'))
    print(string9.rfind('o'))
    
    # 输出结果
    3
    12
    -1
    2
    11
    
    # 注意：index和find都是查找对应的字符并返回其索引值（返回的是第一个查找到的元素的索引值），但是，若查找的字符不存在时，index会直接报错，find会返回-1。

    • 替换字符串中的指定字符

    '''
    .replace
    '''
    
    string10 = 'This-is-a-string.'
    print(string10.replace('-', ' '))
    
    # 输出结果
    This is a string.

    • 指定字符串的编码方式

    '''
    .encode
    '''
    
    string11 = '我可以'
    print(string11.encode('utf-8'))
    
    # 输出结果
    b'\xe6\x88\x91\xe5\x8f\xaf\xe4\xbb\xa5'

• 格式化输出

  • %格式方法

  num1 = 1
  num2 = 1.2345
  string = 'abc'
  print('num1=%d, num2=%.2f, string=%s' % (num1, num2, string))
  
  # 输出结果
  num1=1, num2=1.23, string=abc

  • format格式方法

  num1 = 1
  num2 = 1.2345
  string = 'abc'
  print('num1={}, num2={}, string={}'.format(num1, num2, string))
  print('num1={1}, num2={2}, string={0}'.format(string, num1, num2))
  print('num1={num1}, num2={num2}, string={string}'.format(num1 = 1, num2 = 1.2345, string = 'abc'))
  
  # 输出结果
  num1=1, num2=1.2345, string=abc
  num1=1, num2=1.2345, string=abc
  num1=1, num2=1.2345, string=abc

  • f格式方法

  num1 = 1
  num2 = 1.2345
  string = 'abc'
  print(f'num1={num1}, num2={num2}, string={string}')
  
  # 输出结果
  num1=1, num2=1.2345, string=abc
  
  # 注意：该方法在python3.6之后才可以使用

2.4 列表

• 格式

  list，列表是一个由多个元素组成的有序集合，用[]表示。列表是可变的。

• 列表操作

  • 没有返回值的操作

  '''
  .append
  .extend
  .insert
  .reverse
  .remove
  .sort
  .clear
  '''
  
  list1 = [1, 2, 3, 'a', 'b', 'c', 'a']
  list2 = [5, 6, 7]
  
  list1.append('d')
  list1.extend(list2) # 将list2中的元素按序添加到list1的末尾
  list1.insert(3, 4) # 在索引3的位置插入元素4
  list1.reverse()
  list1.remove('a') # 若元素不存在，则报错
  list2.sort() # 需要列表中的元素是同一类型
  list2.clear() # 将列表list2清空

  • 有返回值的操作

  '''
  .count
  .pop
  .index
  .copy
  '''
  
  list1 = [1, 2, 3, 'a', 'b', 'c', 'a']
  
  print(list1.count('a')) # 返回列表中'a'元素的个数
  print(list1.pop()) # 返回删除的元素
  print(list1.index('a')) # 返回查找到的第一个元素所在的索引，若元素不存在，则报错
  print(list1.copy()) # 返回一个新的列表，该列表的元素和list1完全相同
  
  # 输出结果
  2
  a
  3
  [1, 2, 3, 'a', 'b', 'c']

  • 切片

    列表的切片操作和字符串的切片操作一样。

• 列表推导式

  list1 = [item for item in range(10) if item % 2 == 0]
  print(list1)
  
  # 输出结果
  [0, 2, 4, 6, 8]

2.5 元组

• 格式

  tuple，元组是一个由多个元素组成的有序集合，用()表示。元组是不可变的。注意：只包含一个元素的元组格式为：（元素1，），一定要有一个逗号！

• 元组操作

  • 切片

    元组的切片操作和字符串的切片操作一样。

  • 其他

  '''
  .index
  .count
  '''
  
  tuple1 = (1, 2, 3, 4, 2, 5, 2)
  print(tuple1.index(2)) # 返回查找到的第一个元素所在的索引，若元素不存在，则报错
  print(tuple1.count(2))
  
  # 输出结果
  1
  3

2.6 集合

• 格式

  set，集合是一个由多个不重复的元素组成的无序集合，用{}表示。集合是可变的。

  # 注意：空集合的定义方式为set1 = set()，而不是set2 = {}，后者为空字典的定义方式。
  
  set1 = set()
  set2 = {}
  print(type(set1), type(set2))
  
  # 输出结果
  <class 'set'> <class 'dict'>

• 集合操作

  • 无返回值的操作

  '''
  .add
  .update
  .remove
  .discard
  .clear
  '''
  
  set1 = {1, 3, 5, 7}
  set2 = {2, 4, 6, 8}
  
  set1.add(9)
  set1.update(set2) # 将set2中的元素添加到set1中
  set1.remove(9) # 删除集合中的指定元素，若元素不存在，则报错
  set2.discard(2) # 删除集合中的指定元素，若元素不存在，则操作无效，不报错
  set2.clear()

  • 有返回值的操作

  '''
  .pop
  .copy
  '''
  
  set1 = {1, 3, 5, 7}
  
  print(set1.pop())
  print(set1.copy())
  
  # 输出结果
  1
  {3, 5, 7}

2.7 字典

• 格式

  dict，字典是一个由多个键值对组成的无序集合，用{}表示。集合是可变的。

• 集合操作

  • 无返回值的操作

  '''
  .update
  .clear
  '''
  
  dict1 = {'name':'Aaron', 'age':10, 'email':'aaron@163.com'}
  dict2 = {'email':'12345@qq.com', 'sex':'male'}
  
  dict1.update(dict2) # 将dict2中的键值对添加到dict1中,若存在相同的键，则会替代原来的
  dict2.clear()

  • 有返回值的操作

  '''
  .get
  .keys
  .values
  .items
  .copy
  '''
  
  dict1 = {'name':'Aaron', 'age':10, 'email':'aaron@163.com'}
  
  print(dict1.get('age')) # 根据指定的键查找对应的值，若不存在，则返回None
  print(dict1.keys())
  print(dict1.values())
  print(dict1.items())
  print(dict1.copy())
  
  # 输出结果
  10
  dict_keys(['name', 'age', 'email'])
  dict_values(['Aaron', 10, 'aaron@163.com'])
  dict_items([('name', 'Aaron'), ('age', 10), ('email', 'aaron@163.com')])
  {'name': 'Aaron', 'age': 10, 'email': 'aaron@163.com'}

• 有序字典

  from collections import OrderedDict
  
  info = OrderedDict()
  info['k1'] = 123
  info['k2'] = 456
  
  print(info.keys())
  print(info.values())
  print(info.items())
  
  # 输出结果
  odict_keys(['k1', 'k2'])
  odict_values([123, 456])
  odict_items([('k1', 123), ('k2', 456)])

来源：https://www.cnblogs.com/aaron-zhou/p/11774670.html