Tips：

  • 基础知识类似汉语中的拼音、语法，是后续编程的基础。

  • 本部分主要包含语法格式、数据类型、逻辑判断

语法格式

1 采用缩进。缩进默认四个空格（tab键一般也是4个空格，可使用tab键进行缩进。 代码中缩进必须保持相同空格）。 2 # 开头表示注释，代码执行时会自动忽略 3 当语句以冒号:结尾时，缩进的语句视为代码块。 4 大小写区分

语法格式如下：

  1. # print absolute value of an integer:
  2. a = 100
  3. if a >= 0:
  4.     print(a)
  5. else:
  6.     print(-a)

数据类型

整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

操作：
1 除法：/

  • /除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
    1. >>> 9 / 3
    2. 3.0

2 地板除 //

  • 取整数部分， 两个整数的除法仍然是整数
  1. >>> 10 // 3
  2. 3

3 取余数 % 

    1. >>> 10 % 3
    2. 1

2进制、8进制、10进制、16进制

  • 0b开头表示2进制

  • 0o开头表示8进制

  • 0x开头表示16进制

  • 10进制直接用数字表示

不同进制之间转换：

  • bin()转换为2进制

      1. >>> bin(10)
      2. ob1010

  • int()转换为10进制

  • hex()转换为16进制

  • oct()转换为8进制

  • Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数

浮点数（小数）

即小数，如 0.12
很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，

字符串

  • 字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分

  • 如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

  • 如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如： 

    1. 'I\'m \"OK\"!'

表示的是 I'm "OK"!

  • 转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\

  • 如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义

    1. >>> print('\\\t\\')
    2. \       \
    3. >>> print(r'\\\t\\')
    4. \\\t\\

  • 如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容. 当输入完结束符````和括号)`后，执行该语句并打印结果。

    1. >>> print('''line1
    2. ... line2
    3. ... line3''')
    4. line1
    5. line2
    6. line3

  • 字符串有replace()方法

    1. >>> a = 'abc'
    2. >>> b = a.replace('a', 'A')
    3. >>> b
    4. 'Abc'
    5. >>> a
    6. 'abc'

字符串编码

  • 计算机只能处理数字，字符都需要转换成数字计算机才能处理，转换的方式即字符编码方式。

  • 计算机内部使用unicode编码（兼容ascii等各国文字编码，支持多语言）， 文件使用utf-8编码（节约存储）。

使用

  • len() 获取字符串长度。

  • 字符转字节 str.encode('utf-8') 。 字节转字符 byte.decode('utf-8')

  • 格式化显示字符串

    • 1 %: %s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

      1. >>> 'Age: %s. Gender: %s' % (25, True)
      2. 'Age: 25. Gender: True'

    • 2 format: format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}…… 

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

布尔值

  • True , False , （请注意大小写）

  • 可以通过布尔运算计算出来

  1. >>> True
  2. True
  3. >>> False
  4. False
  5. >>> 3 > 2
  6. True
  7. >>> 3 > 5
  8. False

布尔运算：
用and、or和not运算。

  • and运算是与运算，只有所有都为True，and运算结果才是True：

  • or运算是或运算，只要其中有一个为True，or运算结果就是True：

  • not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

字符串也可以和布尔类型转换显示，空字符串表示False，其他表示True。 注意：空值转换成布尔类型均为False

空值

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

变量

  • 变量不仅可以是数字，还可以是任意数据类型

  • 变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头

  • 等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量

常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量

  • 事实上变量仍然是一个变量，Python根本没有任何机制保常量不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法

List(列表)

list是一种有序的集合，可以随时添加和删除其中的元素.
list里面的元素的数据类型也可以不同,也可以是list

  • 用[]表示
  1. >>> classmates = ['Michael', 'Bob', 'Tracy']
  2. >>> classmates
  3. ['Michael', 'Bob', 'Tracy']

操作：

  • len()函数获得list元素的个数

  • 用索引来访问list中每一个位置的元素，记得索引是从0开始的。超出索引会报错。最后一个元素的索引是len(classmates) - 1。

    1. >>> classmates[0]
    2. 'Michael'
    3. >>>classmates[-1]
    4. 'Tracy'

  • 添加元素 append() 

    1. >>> classmates.append('Adam')    #追加元素到末尾
    2. >>> classmates
    3. ['Michael', 'Bob', 'Tracy', 'Adam']
    4. >>> classmates.insert(1, 'Jack')  #把元素插入到指定的位置，比如索引号为1的位置
    5. >>> classmates
    6. ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

  • 删除元素 pop() ```python

    classmates.pop() #删除末尾元素 ‘Adam’ classmates [‘Michael’, ‘Jack’, ‘Bob’, ‘Tracy’]

classmates.pop(1) #删除指定位置的元素，用pop(i)方法，其中i是索引位置 ‘Jack’ classmates [‘Michael’, ‘Bob’, ‘Tracy’] ```

  • 替换：直接重新赋值

    1. >>> classmates[1] = 'Sarah'
    2. >>> classmates
    3. ['Michael', 'Sarah', 'Tracy']

  • list包含list

    1. >>> s = ['python', 'java', ['asp', 'php'], 'scheme']
    2. >>> len(s)
    3. 4
    4. >>>s[2][0]
    5. 'asp'

Tuple(元组)

tuple，有序不可变列表。 ps：tuple元素指向不可变，但是如果tuple元素是一个可变元素，那么元素内容是可以变的。
tuple和list非常类似，但是tuple一旦初始化就不能修改。当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来
没有append()，insert()这样的方法。其他获取元素的方法和list是一样的
tuple不可变，代码更安全。如果可能，能用tuple代替list就尽量用tuple。

操作

  • 用（）表示 ```python

    classmates = (‘Michael’, ‘Bob’, ‘Tracy’) t = () #定义一个空的tuple，可以写成() t ()

t = (1,) #定义只有1个元素的tuple定义时必须加一个逗号, 和数学公式中的小括号（）区分开 t (1,) #系统在显示的时候也会加一个逗号,，以免你误解成数学计算意义上的括号 ```

Dict(字典)

字典dict，全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度
使用[‘key1’:’value1’, ‘key2’:’value2’]定义
dict是无序的。 内部存放的顺序和key放入的顺序是没有关系的
dict的key必须是不可变对象 在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

  • 根据键查找值

    1. >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    2. >>> d['Michael']
    3. 95

  • 把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

    1. >> d['Adam'] = 67
    2. >>> d['Adam']
    3. 67

    由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉 如果key不存在，dict就会报错

  • 通过in判断key是否存在
    1. >>> 'Thomas' in d
    2. False
  • 通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value
    1. >>> d.get('Thomas')
    2. >>> d.get('Thomas', -1)
    3. -1

    返回None的时候Python的交互环境不显示结果

  • 要删除一个key，用pop(key)方法，对应的value也会从dict中删除
    1. >>> d.pop('Bob')
    2. 75
    3. >>> d
    4. {'Michael': 95, 'Tracy': 85}

Set（集合）

set和dict类似，也是一组key的集合，但不存储value。
set用{}表示，如{1,’ss’,True}
key不能重复，所以，在set中，没有重复的key重复元素在set中自动被过滤
SET是无序的

  • 创建set：要创建一个set，需要提供一个list作为输入集合

    1. >>> s = set([1, 2, 3])
    2. >>> s
    3. {1, 2, 3}

  • 添加删除：

    • 通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果

    • 通过remove(key)方法可以删除元素

  • set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作

    1. >>> s1 = set([1, 2, 3])
    2. >>> s2 = set([2, 3, 4])
    3. >>> s1 & s2
    4. {2, 3}
    5. >>> s1 | s2
    6. {1, 2, 3, 4}

逻辑判断

if（条件判断）

根据条件进行判断，执行符合条件的逻辑。
if语句执行是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else.
条件判断是，只要条件是非零数值、非空字符串、非空list, False等，就判断为True，否则为False。

  • if：如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做

    1. age = 20
    2. if age >= 18:
    3.   print('your age is', age)
    4.   print('adult')

  • if else:如果if判断是False，不要执行if的内容，去把else执行了：

    1. age = 3
    2. if age >= 18:
    3.   print('your age is', age)
    4.   print('adult')
    5. else:
    6.   print('your age is', age)
    7.   print('teenager')

  • if elif else:完全可以用elif做更细致的判断,elif是else if的缩写，完全可以有多个elif

    1. age = 3
    2. if age >= 18:
    3.   print('adult')
    4. elif age >= 6:
    5.   print('teenager')
    6. else:
    7.   print('kid')

循环

1 for in循环：

  • for x in ...循环就是把list或tuple中的每个元素代入变量x，然后执行缩进块的语句
    1. names = ['Michael', 'Bob', 'Tracy']
    2. for name in names:
    3.   print(name)

2 while循环

  • 只要条件满足，就不断循环，条件不满足时退出循环。
    1. sum = 0
    2. n = 99
    3. while n > 0:
    4.   sum = sum + n
    5.   n = n - 2
    6. print(sum)

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

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

continue: 在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

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

  • 不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

  • 有些时候，如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。