Python基础入门笔记（二）| 数据类型&条件语句

这是我参与新手入门的第三篇文章

3.1、Python 基本数据类型

1. 整数

   • Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一样

   • 对于很大的数，例如10000000000，很难数清楚0的个数 Python允许在数字中间以_分隔，因此也可以写成10_000_000_000

   • Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的

2. 浮点数

   • 浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的 1.23x10九次方和12.3x10八次方

   • 对于很大的或很小的浮点数，就必须使用科学计数法

     把10用e替代 写成1.23e9，或者12.3e8，0.000012可以写成1.2e-5
     

   • 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差

   • 浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）

3. 字符串

   • 以单引号'或双引号"括起来的任意文本

   • ''或""本身只是一种表示方式，不是字符串的一部分

     # 可以使用转义字符'\'来标识
     >>> print('I\'m\"ok\"')
     I'm"ok"
     
     # 转义字符'\'可以转义很多字符，比如\n表示换行，\t表示制表符，字符'\'本身也要转义，所以\\表示的字符就是'\'
     
     >>> print("Hello\n\'World\'")
     Hello
     'World'
     
     # Python允许用'''...'''的格式表示多行内容
     >>> print('''line1
     ... line2
     ... line3''')
     line1
     line2
     line3
     

4. 布尔值

   • 布尔值和布尔代数的表示完全一致，一个布尔值只有**True、False**两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（注意大小写）

   • 布尔值的运算

     ## 可以使用and、or和not运算
     
     # and运算是与运算，只有所有都为True，and运算结果才是True
     # or运算是或运算，只要其中有一个为True，or运算结果就是True
     # not运算是非运算，它是一个单目运算符，把True变成False，False变成True
     

5. 列表

   • list是一种有序的集合，可以随时添加和删除其中的元素

     >>> classmates = ['Michael','Bob','Tracy']
     >>> classmates
     ['Michael', 'Bob', 'Tracy']
     
     # len()函数可以获得list元素的个数
     >>> len(classmates)
     3
     
     # 通过索引位置来获取列表中的值 索引从[0]开始
     >>> classmates[0]
     'Michael'
     >>> classmates[1]
     'Bob'
     
     # 还可以用-1做索引，获取最后一个元素，以此类推
     >>> classmates[-1]
     'Tracy'
     

   • list是一个可变的有序表，可以往list中追加元素到末尾

     >>> classmates.append('Adam')
     >>> classmates
     ['Michael', 'Bob', 'Tracy', 'Adam']
     
     # 也可以通过索引插入指定位置
     >>> classmates.insert(1, 'Jack')
     >>> classmates
     ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
     
     # pop()删除list末尾的元素
     >>> classmates.pop()
     'Adam'
     >>> classmates
     ['Michael', 'Jack', 'Bob', 'Tracy']
     
     # 用pop(i)方法，其中i是索引位置删除指定位置的元素
     >>> classmates.pop(1)
     'Jack'
     >>> classmates
     ['Michael', 'Bob', 'Tracy']
     
     # 把某个元素替换成别的元素，直接赋值给对应的索引位置
     >>> classmates[1] = 'Sarah'
     >>> classmates
     ['Michael', 'Sarah', 'Tracy']
     
     

   • list里面的元素的数据类型也可以不同

     >>> L = ['Apple', 123, True]
     

   • list元素也可以是另一个list

     >>> s = ['python', 'java', ['asp', 'php'], 'scheme']
     >>> len(s)
     4
     
     # s可以看成是一个二维数组，类似的还有三维、四维……数组
     >>> s[2][1]
     'php'
     
     # list中一个元素也没有，就是一个空的list，它的长度为0
     >>> L = []
     >>> len(L)
     0
     

6. 元组

   • tuple和list非常类似，但是tuple一旦初始化就不能修改

   • 因为tuple不可变，所以代码更安全

     # 在定义的时候，tuple的元素就必须被确定下来
     >>> t = (1,2)
     >>> t
     (1, 2)
     
     # 空的tuple，可以写成()
     >>> t = ()
     >>> t
     ()
     
     # 只有1个元素的tuple定义时必须加一个逗号,
     >>> t = (1,)
     >>> t
     (1,)
     

   • 可以通过在tuple中添加list 来使tuple中的数据“可变”

     # tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变 但指向的这个list本身是可变的 
     >>> t = ('a', 'b', ['A', 'B'])
     >>> t[2][0] = 'X'
     >>> t[2][1] = 'Y'
     >>> t
     ('a', 'b', ['X', 'Y'])
     

7. 字典

   • dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储 ，具有极快的查找速度

     >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
     >>> d['Michael']
     95
     # 向字典中放入内容
     >>> d['Adam'] = 67v
     >>> d
     {'Michael': 95, 'Bob': 75, 'Tracy': 85, 'Adam': 67}
     
     # 通过in判断key是否存在
     >>> 'Bob' in d
     True
     >>> 'Thomes' in d
      False
     
     # get()方法，如果key不存在，可以返回None，或者自己指定的value
     >>> d.get('Thomes')     # 返回None的时候Python的交互环境不显示结果
     >>> d.get('Thomes',-1)
     -1
     
     # pop(key)方法删除一个key,对应的value也会从dict中删除
     >>> d.pop('Bob')
     >>>   75
     >>> d
     

   • 和list比较的特点 (list相反)：

     • 查找和插入的速度极快，不会随着key的增加而变慢
     • 需要占用大量的内存，内存浪费多

8. set集合

   • 无序和无重复元素的集合

   • set和dict类似，也是一组key的集合，但不存储value

   • 由于key不能重复，所以，在set中，没有重复的key

     # 创建一个set，需要提供一个list作为输入集合
     >>> s = set([1,2,3])
     >>> s
     {1, 2, 3}
     
     # 重复元素在set中自动被过滤
     >>> s = set([1, 1, 2, 2, 3, 3])
     >>> s
     {1, 2, 3}
     
     # 通过add(key)方法可以添加元素到set
     >>> s.add(4)
     >>> s
     {1, 2, 3, 4}
     
     # 通过remove(key)方法可以删除元素
     >>> s.remove(4)
     >>> s
     {1, 2, 3}
     
     # 两个set可以做数学意义上的交集、并集等操作
     >>> s1 = set([1,2,3])
     >>> s2 = set([2,3,4])
     >>> s1 & s2
     {2, 3}
     

   • 不可以放入可变对象，因为无法判断两个可变对象是否相等

9. 空值

   • 空值是Python里一个特殊的值 ，用None表示； None不能理解为0，因为0是有意义的，而None是一个特殊的空值

3.2、字符串和编码

• 字符串的编码问题

  • 对于文字编码各国有各国的标准，就会不可避免地出现冲突，在多语言混合的文本中，显示出来会有乱码
  • Unicode字符把所有语言都统一到一套编码里，解决了这个问题
  • “可变长编码”的UTF-8编码 UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节

• 计算机系统通用的字符编码工作方式

  • 文本编辑时，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件

  

  • 浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器

    # 表示该网页正是用的UTF-8编码
    <meta charset="UTF-8" />
    

  

• Python字符串

  • ord()函数获取字符的整数表示

    >>> ord('a')
    97
    >>> ord('A')
    65
    

  • chr()函数把编码转换为对应的字符

    >>> chr(65)
    'A'
    >>> chr(66)
    'B'
    

  • encode()方法可以编码为指定的bytes

    >>> 'ABC'.encode('ascii')
    b'ABC'
    

  • decode()方法 把bytes变为str

    >>> b'ABC'.decode('ascii')
    'ABC'
    >>> b'ABC'.decode('utf-8')
    'ABC'
    
    # 如果bytes中包含无法解码的字节，decode()方法会报错
    

  • 为了避免乱码问题 ，应当始终坚持使用UTF-8编码对str和bytes进行转换

    # 为了让它按UTF-8编码读取，我们通常在文件开头
    
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    

• 输出格式化的字符串

  • 占位符

    占位符	替换内容
    %d	整数
    %f	浮点数
    %s	字符串
    %x	十六进制整数

• 用%实现

  >>> 'Hello, %s' %'world'
  'Hello, world'
  
  # 格式化整数和浮点数还可以指定是否补0和整数与小数的位数
  >>> print('%2d-%02d' %(3,1))
   3-01
  >>> print('%.2f' %3.1415926)
  3.14
  >>> print('%.3f' %3.1415926)
  3.142
  

  • 字符串里面的%是一个普通字符时，通过转义， 用%%来表示一个%

    >>> 'growth rate: %d %%' %7
    'growth rate: 7 %'
    

  • 使用字符串的format()方法格式化字符串

    >>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
    'Hello, 小明, 成绩提升了 17.1%'
    

  • 使用以f开头的字符串，称之为f-string 以对应的变量替换

    >>> x = 10
    >>> y = 20
    >>> z = x + y
    >>> print(f'{x}+{y}={z}')
    10+20=30
    

4.1、条件判断语句

• 注意：python的缩进规则

  # 语法格式
  if <条件判断1>:
      <执行1>
  elif <条件判断2>:
      <执行2>
  elif <条件判断3>:
      <执行3>
  else:
      <执行4>
  
  # 例：
  age = 7
  if age >= 18:
      print('adult')
  elif age >= 6:
      print('teenager')
  else:
      print('kid')
      
  
  

• if语句执行有个特点，它是从上往下判断 ，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else

  # input()返回的数据类型是str，str不能直接和整数比较
  
  # 通过int()函数将str转换成整数
  s = input('birth:')
  birth = int(s)
  if birth < 2000:
      print('00前')
  else:
      print('00后')
  
  #@ 注： int()函数发现一个字符串并不是合法的数字时就会报错
  

4.2、循环语句

• for...in循环： 依次把list或tuple中的每个元素迭代

  # for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句
  names = ['Michael', 'Bob', 'Tracy']
  for name in names:
      print(name)
  
  # 例：计算1-10的整数和
  sum = 0
  for x in [1,2,3,4,5,6,7,8,9,10]:
      sum = sum + x
  print(sum)
  
  # 通过range()函数可以生成一个整数序列；再通过list()函数可以转换为list
  >>> list(range(5))
  [0, 1, 2, 3, 4]
  

• while循环： 只要条件满足，就不断循环，条件不满足时退出循环

  # 例：在循环内部变量n不断自减，直到变为-1时，不再满足while条件，循环退出
  sum = 0
  n = 99
  while n > 0:
      sum = sum + n
      n = n -2
  print(sum)
  

• break： 在循环中，break语句可以提前退出循环

  n = 1
  while n <= 100:
      if n > 10: 	# 当n = 11时，条件满足，执行break语句
          break 	# break语句会结束当前循环
      print(n)
      n = n + 1
  print('END')
  

• continue: 跳过当前的这次循环

  n = 0
  while n < 10:
      n = n + 1
      if n % 2 == 0: # 如果n是偶数，执行continue语句
          continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
      print(n)
  

• 注意：

  • break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环
  • break和continue会造成代码执行逻辑分叉过多，容易出错