Python基础-01

一、基础概念

1.1 变量和常量

1.1.1 变量

① 查看变量的内存地址

id(x)

② 为变量赋值

• 通过=来赋值

x = 3

1.1.2 常量

• python没有常量这个数据类型
• 程序员之间的约定: 如果这个变量的命名都是大写字母, 那么就视为一个常量
• 常量的值不改变

INT = 1

1.2 Python的六大基本类型

1.2.1 Int 、Float 、String

• 通过type()函数来查看当前变量的数据类型

• int (整数)

  int('1')
  

• float(浮点数)

  float('1.0')
  float('INF')
  

• 因为计算机内部只认识1和0, 所以浮点数强调的时小数的表现形式

• string(字符串)

  str(2)
  

  • 在有些语言中, 单个字符也是一个基本的数据类型(Char)

  • 有序的

  • 如何表示字符串

    • 'test'
    • "test"
    • '''test'''
    • """test"""

  • 转义字符

    告诉python, 我们当前要表示的是一个字符或者是特殊字符

    • 通过\来转义

      "2\""   --->  2"
      "2\n"   --->  2 enter
      ``
      
      

1.2.2 布尔值 、bytes 、None

• boolean(布尔值)

  bool(2)    ---> True
  bool(0)    ---> False
  

  用来表示True或者False

  • True 等价于1
  • False等价于0

• bytes(二进制序列)

  二进制的表示形式

• None(空)

  • 有了False和0 为什么还要有None

    因为False和0有时候也代表了一种结果

1.3 Python的四大基本数据结构

1.3.1 list列表类型与tuple元组类型

• list(列表)

  • 列表 用来装载不同数据类型的数据集结构

  • 特点

    • 有序的
    • 可以装载任意数据类型
    • 可以更改的

  • 如何表示list

    • 通过list()新建一个列表

      list("hello world")
      

    • 通过[]声明一个列表

      a = [1, 2, 3]
      

• tuple(元组)

  • 元组 可以简单地认为, 元组就是不可修改的列表, 常用来表示记录.

  • 特点

    • 有序的
    • 可以装载任意数据类型
    • 不可更改

  • 如何表示tuple

    • 通过tuple()新建一个元组

      tuple("hello")
      

    • 通过(,)来声明一个元组

      a = (1, 2, 3)
      
      #声明单个元素的元组, 要添加逗号
      a = (1, )
      ``
      
      

1.3.2 dict字典类型与set集合类型

• dict(字典)

  • 字典叫hashtable, 通过hash(散列)函数将传入的key值生成地址来查找value

    key -> hash函数 -> 返回了value的地址 -> 通过地址返回value值

  • 特点

    • 无序的

      python3.6是有序的, 无视这一点.

    • 字典中的key必须是可hash的, 也就是不可更改的, 唯一的

    • 可以更改的

  • 表示字典

    • 通过dict()来创建字典

      dict(a=2)
      

    • 通过{}来声明一个字典

      a = {"a": 2}
      

• set(集合)

  • set其实是没有value的字典

    -特点

    • 无序的
    • 集合中的key必须是可hash的
    • 可以更改的
    • 元素是唯一的

  • 表示set

    • 通过set()来创建集合

      set([1,2,2])
      

    • 通过{}来表示

      {1, 2, 3}
      

二、函数、运算符与数据类型的常用方法

2.1 函数

2.1.1 介绍

• 函数 是一段可被另外一段程序引用的程序或代码，也叫子程序，方法
  • 可重复使用
  • 可相互调用
• 目的
  • 代码的复用

2.1.2 函数的组成

• 参数列表

  • 函数的参数列表必须按顺序传入

  • 不定长参数

       def Demo(*args):
       	print(args)
       
       print(Demo("a","b"))
    

• 函数体
• 返回值

  • 不写默认返回None

    def Demo(a1, a2):
        return a1+"Hello"+a2
    
    print(Demo("a","b"))
    

    aHellob
    

2.2 运算符

2.2.1 算术运算符，赋值运算符，比较运算符

• 算术运算
  • 加减乘除 + - * /
  • 整除 //
  • 取余 %
  • x的y次幂
  • 开方
  • 绝对值

      s=5//2   //2
      s=5%2    //1
      s=2**4   //16
      s=x**(1/2)   //x的1/2次方
      s=abs(-2)   //2
    

  • 赋值运算符

      a=1
    

• 比较运算符
  比较两个对象的字面量

  s="abc"
  d="abbc"		
  print(s>d)
  //True 字符串的字符逐个比较大小
  

• 标识符比较符 is

  s="你好"
  d="你好"		
  print(s is d) 
  //True 比较两个变量的内存地址
  

2.2.2 成员检测运算与布尔运算

• 成员检测运算
  判断元素是否在当前序列中 in

  	a=[1,2,3]
  	b=1
  	print(b in a) 
  	//True
  	a=[1,2,3]
  	b=[1,2]
  	print(b in a) 
  	//False
  

  判断元素是否在当前序列中 not in

• 布尔运算

  • and 与
    两边都为True才返回True
  • or 或
    两边有1个True，返回True
    短路逻辑：A为True时，B不会运行
  • not 逻辑取反

2.2.3 位运算与运算符优先级

• 位运算
  对二进制进行运算

  • -
  • ^
  • >>
  • <<
  • &
  • |

• Python运算符优先级

  

2.3 数据类型的常用方法

2.3.1 字符串创建及常用方法

• 字符串的创建

  str="abcd"
  print(str) 
  //abcd
  

• 检索

  • 根据索引获取字符

    str="abcd"
    print(str[2]) 
    //c
    

  • find方法

    str="abcd"
    print(str.find("c")) 
    //2
    

  • index方法

    str="abcd"
    print(str.index("c")) 
    //2
    

• 常用方法

  • startswith()以…开头

    	str="abcd"
    	str.startswith("ab")
    	print(str.startswith("ab")) 
    	//True
    

  • endswith()以…结尾

    	str="abcd"
    	str.endswith("ab")
    	print(str.startswith("ab")) 
    	//False
    

  • replace（）替换

    	str="hello,hello,hello"
    	str.replace("h","w")
    	print(str.replace("h","w")) 
    	//wello,wello,wello
    

  • split()分割

    	str="hello,hello,hello"
    	str.split(",")
    	print(str.split(",")) 
    	//['hello', 'hello', 'hello']
    

  • join()拼接

    	str = ['hello', 'hello', 'hello']
    	newstr = ",".join(str)
    	print(newstr) 
    	//hello,hello,hello
    

  • strip()去除首尾空格

    str ="   hello        "
    print(str.strip())
    //hello
    print(str.rstrip()) 
    //   hello
    print(str.lstrip()) 
    //hello  
    

2.3.2 字符串写入文件及格式化输出

• 字符串写入文件

  	#打开一个文件，没有会创建（文件名，方法（读，写，追加），编码格式）
  	output = open("test.txt","w",encoding="utf-8")
  	content = "hello world"
  	#正式写入文件
  	output.write(content)
  	#关闭文件句柄
  	output.close()
  

• 读取文件中的内容

  	#打开一个文件，没有会创建（文件名，方法（读，写，追加），编码格式）
  	input = open("test.txt","r",encoding="utf-8")
  	#读取文件
  	content = input.read()
  	print(content)
  	//hello world
  

• 字符串格式化输出

  	a="abc"
  	b="efg"
  	print("play:{}{}".format(a,b))
  	//play:abcefg
  

按固定索引

	a="abc"
	b="efg"
	print("play:{0}{1}{0}{1}".format(a,b))
	//play:abcefgabcefg

按变量

	a="abc"
	b="efg"
	print(f"play:{a}{b}")
	//play:abcefg

• 小数表示

  print("{:.2f}".format(3.1415926))
  //3.14
  

2.4 变量与引用

• 变量就是指向一个实体
• 引用好就是指向变量的变量

2.5 list列表常用方法

• list中的元素是引用

• append添加元素

  list = [1,2]
  list.append(3)
  print(list)
  //[1, 2, 3]
  

• + 拼接
  拼接两个列表，返回一个新列表

  	list1 = [1,2]
  	list2 = [1,2]
  	list3 = list1 + list2
  	print(list3)
  	//[1, 2, 1, 2]
  

• += 拼接
  拼接原有列表

  	list1 = [1,2]
  	list1 += [32]
  	print(list1)
  	//[1, 2, 32]
  

• *批量添加
  引用的地址都一样

  	a = 1
  	list1 = [a]*10
  	print(list1)
  	//[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
  

• insert插入元素

  	list1 = [1]
  	list1.insert(0,2)
  	print(list1)
  	//[2, 1]
  

• list[start:end]索引取值 切片

  list = list(range(20))
  #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
  print(list[10:15])
  //[10, 11, 12, 13, 14]
  

• list[-1]取最后一个值

  list = list(range(20))
  #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
  print(list[-1])
  //19
  

• index获取元素的索引

  list = ["a","b","c","d"]
  print(list.index("d"))
  //3
  

• pop 删除最后一个元素，并返回被删除的元素

  	list = ["a","b","c","d"]
  	print(list.pop())
  	//d
  

• clear()清除列表
  清除列表的元素，不改变列表的内存地址

• sort()排序 升序

  	list = [3,7,1,0,5]
  	list.sort()
  	print(list)
  	//[0, 1, 3, 5, 7]
  

• sorted()排序 返回新列表

  	list = [3,7,1,0,5]
  	newlist = sorted(list)
  	print(list)
  	print(newlist)
  	//[3, 7, 1, 0, 5]
  	//[0, 1, 3, 5, 7]
  

• reverse()倒序

  	list = [3,7,1,0,5]
  	list.reverse()
  	print(list)
  	//[5, 0, 1, 7, 3]
  

• reversed()倒序 返回新列表

  	list = [3,7,1,0,5]
  	newlist = list.reversed()
  	print(newlist)
  	//[5, 0, 1, 7, 3]
  

2.6 dict字典常用方法

• 键值对赋值

  • update合并字典

    	d1 = {"a":1}
    	d2 = {"b":2,"c":3}
    	d1.update(d2)
    	print(d1)
    	//{'a': 1, 'b': 2, 'c': 3}
    

  • setdefault设置dict的值，如不存在赋值，存在则不赋值

    	d1 = {"a":1,"b":2,"c":3}
    	d1.setdefault("e",0)
    	print(d1)
    	//{'a': 1, 'b': 2, 'c': 3, 'e': 0}
    	d1 = {"a":1,"b":2,"c":3}
    	d1.setdefault("b",10)
    	print(d1)
    	//{'a': 1, 'b': 2, 'c': 3}
    

• 键值对查询

  • 键对值访问 没有会报错

    	d1 = {"a":1,"b":20,"c":3}
    	print(d1["b"])
    	//20
    

  • get键对值访问 没有返回None,还可以返回默认值

    	d1 = {"a":1,"b":2,"c":3}
    	print(d1.get("d"))
    	//None
    	d1 = {"a":1,"b":2,"c":3}
    	print(d1.get("d",100))
    	//100
    

  • keys获取所有键

    	d1 = {"a":1,"b":2,"c":3}
    	list1 = list(d1.keys())
    	print(list1)
    	//['a', 'b', 'c']
    

  • values获取所有值

    	d1 = {"a":1,"b":2,"c":3}
    	list1 = list(d1.values())
    	print(list1)
    	//[1, 2, 3]
    

  • items获取所有键值对

    	d1 = {"a":1,"b":2,"c":3}
    	list1 = list(d1.items())
    	print(list1)
    	//[('a', 1), ('b', 2), ('c', 3)]
    

• 删除键值对
  • pop删除当前元素，返回value
  • popitem随机删除，返回item
  • clear清空键值对

2.7 set集合常用方法

没有键值的集合 值不重复

• 添加

  • add添加值

  	set={1,2,3}
  	set.add(4)
  	print(set)
  	//{1, 2, 3, 4}
  

• 检索值

  • in成员检测

  	set={1,2,3}
  	print(1 in set)
  	//True
  

• 更新值

  • union合并两个set，返回一个新的set

• 删除值

  • remove 删除不存在的值报错
  • discard 删除不存在的值不报错
  • pop无序删除，并返回值

三、流程控制、循环语句、异常处理

3.1 流程控制语句(if、elif、else)

• if、elif、else

	a = 50
	if a > 100:
	    print("a 超过阈值")
	elif a == 50:
	    print("a 只有阈值的一半")
	else:
	    print("a 小于阈值")
	#a 只有阈值的一半

3.2 循环语句for与while

• for

  • 遍历一个可迭代对象(暂时理解为list), 会影响相同作用域当中的变量

    list = [1, 2, 3, 4, 5, 6]
    #for 遍历得到的值 in 遍历的对象
    for i in list:
        print(i)
    #改变了相同作用域i的值
    print(f"final i value: {i}")
    #1
    #2
    #3
    #4
    #5
    #6
    #final i value: 6
    

  • 获取索引值和值

    list = [1, 2, 3, 4, 5, 6]
       
    for i, e in enumerate(list):
        print(f"index: {i}, value: {e}")
    #index: 0, value: 1
    #index: 1, value: 2
    #index: 2, value: 3
    #index: 3, value: 4
    #index: 4, value: 5
    #index: 5, value: 6
    

• while
  一定要有逻辑判断语句来退出while循环

  	while 判断语句:
  	    	表达式
  	    
  	while True:
  		判断语句
  		表达式
  

• 跳出循环

  • break

    停止当前循环

  • continue

    跳过当前的执行逻辑, 立即执行下一个循环语句单元;

  • pass

    跳过当前条件判断中的执行语句, 后续语句继续执行;

3.3 异常处理

• 程序遇到严重错误时, 会终止程序的运行并抛出异常

  def my_sub(a, b):
        return a / b
    
  my_sub(1, 0)
  #ZeroDivisionError: division by zero
  

• 捕获异常
  格式

  try:
    	表达式
  except [Exception] as e:
  	表达式
  finnaly:
  	表达式
  

  	def my_sub(a, b):
  		try:
  		    return a / b
  		except ZeroDivisionError as :
  		    print(e)
  		    #print("分母不可为0")
  		    return None
  		finally:
  		    print("function my_sub end")
  	
  	my_sub(1, 0)
  #division by zero
  #function my_sub end
  

• Exception

  所有异常的基类, 所有的异常都是Exception的子类

  • 处理异常要细一点, 尽量不要捕获基类Exception
  • 常见的异常
    • IndexError
      索引值超过了列表长度

     l = [1]
     print(l[2])
     #IndexError: list index out of range
    

    • KeyError
      找不到Key

    d = {"a": 1}
    print(d["b"])
    #KeyError: 'b'
    

    • ValueError
      传入的参数错误

    int('a1')
    #ValueError: invalid literal for int() with base 10: 'a1'
    

    • TypeError
      类型错误, 常见于运算

    print(1 + '2')
    #TypeError: unsupported operand type(s) for +: 'int' and 'str'
    

    • SyntaxError
      语法报错, 检查自己的语法有没有写错

    • IndentationError
      缩进错误

      • 混用tab和space(空格)
      • 缩进长度不对

• 如何处理异常

  • 抛出新异常

    def my_sub(a, b):
        try:
            return a / b
        except ZeroDivisionError:
            print("分母不可为0")
            raise Exception("params error")
        finally:
            print("function my_sub end")
    

  • 重新抛出

    def my_sub(a, b):
       try:
           return a / b
       except ZeroDivisionError:
           print("分母不可为0")
           raise ZeroDivisionError
       finally:
           print("function my_sub end")
    

  • 忽略(不推荐)
    pass
    用来指示当前处理语句没有正式写完, 尽量不要忽略异常, 否则代码的健壮度会很差, 造成不可预知的bug.

  • 自定义异常

     class ParamsError(Exception):
        pass
        
     def my_sub(a, b):
         try:
             return a / b
         except ZeroDivisionError:
             raise ParamsError("分母不可以为0")
         finally:
             print("function my_sub end")  
    

四、函数

4.1 内置函数

• 认识Python自带的, 可全局调用的函数, 避免我们命名冲突导致了函数性状发生改变

  • 查看Python携带的内置函数

    from pprint import pprint
    # 格式化输出的库
    pprint(dir(__builtins__))
    

• 常见的内置函数

  • str

    str(1.0)
    #1.0
    

  • int

    int(1.0)
    #1
    int("1.0")
    #ValueError: invalid literal for int() with base 10: '1.0'
    int("1")
    #1
    

  • float

    float("1.0")
    #1.0
    float(1)
    #1.0
    float('1')
    #1.0
    

  • bytes

    bytes('a'.encode("utf-8"))
    #b'a'
    

  • bool

    	bool(0)
    	 #False
    	bool(1)
    	 #True
    	bool(2)
    	 #True
    	 bool(0.0)
    	 #False
    

  • list
    只要是序列都可以转换成list

     list("qwe")
    #['q', 'w', 'e']
    

  • tuple

     tuple("qwe")
    #('q', 'w', 'e')
     tuple([1,2])
    #(1, 2)
    

  • dict

    dict(a=1)
    #{'a': 1}
    

  • set

     set([1,2,2])
    #{1, 2}
    set("qweqweqwe")
    #{'q', 'w', 'e'}
    

  • id
    查看当前对象的内存地址

     a = "1"
     id(a)
    #26114944
    

  • dir

    • 当前对象下的所有方法和属性
    • 在Python中一切皆为对象

    dir(__builtins__)
    

  • max
    返回一个序列中的最大值

    max([2, 4,67,1])
    #67
    

  • min
    返回一个序列中的最小值

    min([2, 4,67,1])
    #1
    

  • range
    返回一组数字区间的可迭代对象

  for i in range(10):
  #1,2,3,4,5,6,7,8,9
  

4.2 函数的形参和实参

• 形参
  形式参数, 简单地说就是还没接受到实际值的参数. 函数未调用时就是形参

  def my_power(a, b):
      return a ** b
  

• 实参
  实际传入的参数, 函数调用时传入的值就叫实参

  print(my_power(2, 3))
  

• 函数的返回值

• 返回值的类型: 任意类型, 包括函数本身

• 如何接受返回值

  • 接收单个值

  • 一个变量接受返回的多个值
    实际上返回的是个tuple

  def foo(a, b):
  	return a*2, b*2     
  result = foo(1, 2)
  #(2, 4)
  

  • 多个变量按顺序接收
    实现原理是元组解包(unpack)

   a,b = foo(1,2)
   #2
   #4
   # 等同于
   result = foo(1,2)
   a, b = result
  

  • 不定长变量接收
    首尾

  (1, 2, 3, 4, 5, 6, 7)
   a, *b, c = result
   #a 1
   #c 7
   #b [2, 3, 4, 5, 6]
  

4.3 匿名函数

匿名函数就是没有名字的函数, 一般都是提供给高阶函数调用

• 通过lambda关键字来声明匿名函数

  lambda x: x **2
  # 返回的是一个匿名函数对象
  <function <lambda> at 0x018BB660>
  

• 函数体是纯表达式

  • 不能有复杂的逻辑判断语句

    • 唯一例外的例子:

      lambda x: 返回值 if 纯表达式 else 返回值
      
      lambda x: True if  x % 2==0 else False
      

  • 不能有循环语句

  • 不能有异常捕获

  • 不能有赋值语句

  • 不能有return

  • 默认表达式运行的结果就是返回值

    lambda x: x **2
    返回值就是 x**2
    

• 按第二个值排序

    l = [[1,2], [2,1], [6,4], [3,5]]
    l.sort(key=lambda x: x[1])
    print(l)
    #[2,1],[1,2], [6,4], [3,5]
  

4.4 高阶函数

接受函数作为参数, 或者把函数作为结果返回

• map(映射)

map(function,iterable,...)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。
把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。

对一个序列每个元素进行相同的操作, 这个过程就叫映射

 l = [1,2,3]
 m = map(lambda x: x**2, [1,2,3])
 # 获得返回结果是一个map对象 
 # map对象是一个可迭代对象, 需要驱动可迭代对象返回值, list就有这样的功能. 暂时不要太纠结
 list(m)
 [1, 4, 9]
 l
 [1, 2, 3]

• 等同于以下:

  def my_powser_2(a):
  	return a ** 2
  
  # 匿名函数只是图方便, 所有的匿名都可以通过正常函数替换
  m = map(my_powser_2, [1,2,3])
  list(m)
  [1, 4, 9]
  

• 多用于和math库进行运算操作

  >>> m = map(math.sqrt, [1, 4, 9, 16, 25])
  >>> list(m)
  [1.0, 2.0, 3.0, 4.0, 5.0]
  

• filter(过滤)

    filter(函数, 可迭代对象)
    函数中的表达式返回结果为False, 就会被过滤
  

    L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    # 过滤偶数
     f = filter(lambda x: x%2, L)
     list(f)
    [1, 3, 5, 7, 9]
    
    # 过滤奇数
     f = filter(lambda x: False if x%2 == 1 else True, L)
     list(f)
    [0, 2, 4, 6, 8]
  

4.5 递归函数

在函数中调用自身的函数就叫递归函数

F(n) = F(F(n-1))

• 声明一个递归函数(阶乘)
  • 一定要有退出机制

  F(n) = n * F(n-1)
  
  def fact(n):
      if n == 1:
          return 1
      return n * fact(n-1)