一、变量和数据类型

徘徊边缘 提交于 2020-02-25 15:53:55

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)])
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!