Jocx's blog

来了就先看看吧，没准有用呢？

0%

【语法】Python基础语法

更新于 分类于
本文字数： 4.5k 阅读时长 ≈ 4 分钟

Python基础语法

——这里只记录3.7及其以上版本的内容

[toc]

1.字符串

构造字符串

直接用__单引号__或者__双引号__就可以构造字符串了

基本操作

  • [ ]：访问__字符__或者__子字符串__，也成为字符串的切片操作

    1
    2
    3
    a = 'sd是dsf\dfsdf'
    b = a[1:4]  # d是d
    c = a[3]  # d

  • +：拼接字符串，返回拼接好的字符串

  • *：使字符串重复

    1
    2
    a = 'great'
    b = a * 2  # 'greatgreat'

  • in、not in：判断字符/子字符串是否在字符串中，返回_True_或者_False_

  • r/R：加在原始字符串处，表示无视转义符

转义符

：换行

置表

格式化表示（format）

format()可以很灵活地处理字符的格式化，特点是不受参数个数限制，并且可以不按照顺序来排。如果不设置指定位置就是按照默认顺序排。

1
a = '{0} {1} {0}'.format('a', 'b')  # 'a b a'

format()也可以通过关键字形参的费的方式来进行匹配

1
a = '{a} {b} {a}'.format(a = 'aaa', b = 'bbb')  # aaa bbb aaa

以字典为参数来匹配

1
2
site = {'a': 'aaa', 'b': 'bbb'}
a = '{a} {b} {a}'.format(**site)  # aaa bbb aaa

以序列对象来作为参数

1
2
kk = ['aaa', 'bbb']
a = '{0[1]} {0[0]} {0[1]}'.format(kk)  # bbb aaa bbb

__{ }__里面还可以设置一些关于格式的内容：

内容 格式 输出 描述
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {:+.2f} +3.14 带符号保留小数点后两位，符号与__内容__符号一致
5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)，不写x的情况下__默认是空格__
1000000 {:,} 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00e+09 指数记法
11 {:b} 1011 二进制
11 {:d} 11 十进制
11 {:o} 13 八进制
11 {:x} b 十六进制
11 {:#x} 0xb 有前缀码提示的进制表示，x可以换成其他的进制格式

方法

  • title()：使英文开头大写
  • upper()：使英文字母全大写
  • lower()：使英文字母全小写
  • swapcase()：翻转大小写
  • strip(s)：s是字符串类型，表示删除首尾指定字符串，默认是空格和换行符
  • lstrip(s)：strip()左边版
  • rstrip(s)：strip()右边版

更多方法可以见：Python 字符串

2.数字

说明

Python Number 数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。

3种数字类型

  • 整型(Int)：可正可负

  • 浮点型(float point real values)：就是所谓的小数，可以用科学计数法表示

    1
    a = 2.5e2 # a为2500

  • 复数(complex numbers)：复数，实部和虚部都是浮点型

    1
    2
    3
    a = 3+4j # 也可以是3+4J
    a = complex(3,4e0)
    print(a) # (3+4j)

  • Python 3.7 已经不支持长整型了

基本运算

  • +、-、*、/ 分别对应加减乘除，%、// 分别是取模和取商，** 是乘方

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    a = 1
    b = 2
    c = a + b # 3
    c = a - b # -1
    c = a * b # 2
    c = a / b # 0.5，经过除法就会变成浮点数

    c = a % b # 2 取余数
    c = b // a # 2 取商

    c = a ** b # 1 1的2次方

  • del：关键字，后面跟number对象，可以将对象删除

    1
    2
    3
    4
    # 可以用del删除一个或者多个语句
    var = var_a = var_b = 1
    del var
    del var_a, var_b

内置函数（库里面可以直接用的方法）

类型转换

  • int( str/ number)：将参数转换为整形数据，返回值为整数，没有参数的话会返回0

    1
    2
    3
    4
    a = '12'
    b = 12.5
    c = int(a) # 结果是12
    c = int(b) # 结果是12

  • float( str/ number)：将参数转换为浮点型数据，但会将整数变成一位小数,返回值是浮点数

    1
    2
    3
    4
    a = '12'
    b = 12
    c = float(a) # 结果是12.0
    c = float(b) # 结果是12.0

  • eval( str)：将字符串转化成对应的数字

  • oct( number)：将整数转换为对应的八进制字符串

    1
    2
    a = 25
    b = oct(a) # 0o25

  • hex( number)：将整数转换为对应的十六进制字符串

    1
    2
    a = 25
    b = hex(a) # 0x15

  • ord( char)：将__字符__转变成对应的整数

    1
    2
    a = 'A'
    b = ord(a) # 65

  • 小技巧：将整数转化成对应的__Unicode字符__可以用unichr( number)

    1
    2
    3
    from pyparsing import unichr # 从pyparsing包里引入
    a = 65
    b = unichr(a) # A

数学运算（部分）

  • round(x, a)：将x转化为四舍五入保留a位小数，a的默认情况是四舍五入保留整数，返回值是数字

    1
    2
    a = 6.34
    b = round(a, 1) # b为6.3

  • abs(x)：返回x的绝对值，返回值类型以x来定

  • max(x1, x2, x3, ...)：返回最大值

    1
    2
    3
    A = [1, 2, 3]
    b = max(A) # 3
    b = max(1, 2, 3) # 3

  • min(x1, x2, x3, ...)：返回最小值，同上

  • pow(x, y)：返回x的y次方

math、cmath包

简介

这两个包是数学包，前者是处理实数的，后者是处理复数的。可以将包引入，然后进行一些__对数、指数、三角函数、反三角函数__的运算

部分函数符号

大部分数学函数与数学符号相同，故只需要在这里展示_特殊的数学函数_

  • 开方：sqrt()
  • 三角函数系列：cos, sin, tan，用的都是弧度制
  • 反三角函数系列：acos, asin, atan
  • 对指数：log, log2, log10, exp
  • 向上取、向下取：ceil, floor

特殊的函数：

  • hypot(x, y)：取x和y的欧几里得范数
  • degrees(x)：将弧度转为角度
  • radians(x)：将角度转为弧度
  • modf(x)：x为浮点数，返回一个元组，第一个元素是x的小数部分，第二个元素是x的整数部分。两个元素符号与x有关

3.数据流操作

条件语句

1
2
3
4
5
6
7
8
9
# 用的是if-elif-else结构
a = 10
if a < 9:
    b = 1
elif a > 12:
    b = 2
else:
    b = 3
print(b)  # 3

循环语句

分为while循环和for循环，并且两者可以嵌套

  • while循环：

    1
    2
    3
    4
    5
    6
    7
    8
    count2 = 0
    while count2 < 3:
        print('The count is: ', count2)
        count2 = count2 + 1

    # The count is:  0
    # The count is:  1
    # The count is:  2

  • while-else：else和while对齐，只要在while正常进行完就会触发else，若是break中断就不会

  • for循环：

    1
    2
    3
    4
    5
    6
    7
    # 后面都必须是可迭代对象
    for i in 'Python':
        pass
    for i in [1, 2, 3]:
        pass
    for i in range(3):  # range(i, j)：是左闭右开
        pass

  • for-else：else和for对齐，只要在for正常进行完就会触发else，若是break中断就不会

控制语句

  • continue：表示流继续
  • break：表示流中断
  • pass：空语句，什么都不干。也可以用于自定义函数

4.自定义函数

通用结构

1
2
3
def functionName (parameters):  # 函数名, 形参列表, 冒号
    function_block  # 函数语块
    return something  # 返回值, 可以不要return不返回

  • 相关概念（这部分比较简单，不过多赘述）：

    • 位置实参

    • 关键字实参

    • 默认参数

      1
      2
      def functionName (a, b = 35):  # 在定义函数时就将b的默认值设置好
          pass

    • 在传递实参的时候建立元组（可以传递任意数量实参）

      1
      2
      def functionName (*a):  # a是元组形参
          pass

    • 在传递实参的时候建立字典（可以传递任意数量的关键字实参）

      1
      2
      3
      4
      5
      def functionName (**s):  # s是字典形参
          pass

      # 调用时：
      functionName(a = 'as', b = 122)  # 这样s[a]就是'as'了

    • 注意：在传递多种参数的时候，__先__位置实参、__再__关键字实参、__最后__任意实参

  • 匿名函数：可以用于自定义类排序

    1
    kk = lambda stu, tic: stu - tic  # 返回值, 不需要函数名, 形参列表, 语句逻辑。注意，stu和tic都是匿名参数

5.自定义类

6.异常处理

说明

只有当程序遇到不可处理的部分的时候才会触发异常。

基本格式

  • try-except-else-finally：异常的基本结构

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def func():
        pass
    # try-except-else-finally结构
    try:  # try语句里面放可能会出现异常的句子
    	func()  # Python语句
    except BaseException:  # except后面跟异常的名字
        print('BaseError!')
    else:  # 不发生异常就会执行
        print('nothing')
    finally:  # 不论有无异常都会执行
        print('ohh')

  • except：处理异常的基本语句

    1
    2
    3
    4
    5
    6
    7
    8
    #...
    except BaseException:  # except后面跟异常的名字
    except (IOError, ValueError):  # except后面可以跟多个异常的名字
    except:  # except后面可以什么都不跟，发生异常就执行
    except Exception as ll:  # 生成一个异常实例
        print(ll.args)  # 调用Exception实例对象的参数属性
        # 这个属性是一个元组，显示异常的原因
    #...

    执行我们在安排except的时候，都是以范围从小到大地进行except安排。因为执行了其中一个except后就不会执行其他except了 更多Python 异常名字

  • raise：主动抛出一个异常。后面也可以抛出一个异常的构造函数

    1
    2
    3
    raise Exception('dfdff')  、
    # 括号里面的内容是传给args属性
    # 可以是数字、字符串、元组

    raise会将异常抛给上一层栈。所以一般用在函数里面

  • 自定义异常，这个用的比较多。应该是直接或者间接地继承Exception类

    1
    2
    3
    class myException(Exception):
        def __init__(self, args):
            self.args = args  # 一般会编写一个args属性

7.列表

说明

列表是Python里面最基础的数据结构。列表里面可以装_任意不同种类的元素_

构造方式：

Python的列表只能拷贝构造，或者用构造函数接受一个元组对象来构造

1
2
3
4
# 拷贝构造
a = [1, 'dfdf', 2]
# 用元组对象构造
a = list((1, 'dfdf', 2))

基本操作

  • +：将两个列表合在一起，返回那个合在一起的新列表

  • *：用法是__LIST * INT__，将这个列表里面的元素重复INT次后成为的新列表返回

  • =：LIST1 = LIST2，LIST1将是LIST2的_引用_

  • []：访问列表里面的值，这个也是返回_引用_

    1
    2
    3
    b = ['dfd'] * 3  # []也是左闭右开的原则
    b[1:3] = ['ji']  # 原始的b[1:3]是['dfd', 'dfd']
    print(b)  # 此时的b变成了['dfd', 'ji']

  • del LIST[index]：del语句删除列表内元素。LIST是列表名字，index是下标

  • del LIST：删除整个列表

  • in：可以判断元素是否在列表内

  • not in：可以判断元素是否不在列表内

内置函数（可以直接调用的方法）

  • max(lis)：lis是列表，这样可以找到列表里最大值
  • min(lis)：lis是列表，这样可以找到列表里最小值
  • len(lis)：lis是列表，返回lis的长度
  • sum(lis, num)：lis是数字列表，num是数字（默认为0），返回加完lis后再加上num的值

方法

添加内容：

  • append(obj)：obj是对象。此方法可以使obj变成列表的元素，但只能加在末尾，无返回值
  • extend(iteObj)：iteObj是可迭代对象。将列表扩展开，装下iteObj中元素，无返回值

改变顺序：

  • sort(key=function(xx), reverse=False)：key和reverse都是关键字形参，代表排序的依据和是否降序。默认key是元素本身，reverse为False。key就可以接受一个lambda函数来根据一些对象属性来排序，无返回值
  • reverse()：将列表翻转，无返回值

真-复制：

  • copy()：重新开一个新空间，复制元素给他，返回一个新的一模一样的列表

数据结构上的操作：

  • remove(obj)：删除与obj匹配到的第一个元素

  • clear()：清除列表中的所有元素。不考虑性能的话一般不常用。你都用Python了还考虑个锤子性能

  • insert(index, obj)：将obj插入index下标里面，然后index后面的元素向后移。index超出了就会将obj排在最后

  • pop(index)：index是下标，弹出下标对应的元素，然后返回该元素

其他操作：

  • count(obj)：返回obj元素在这个列表里的个数
  • index(obj)：返回这个obj在这个列表里的下标

一些操作：

  • 一行对一个列表进行操作

    1
    2
    3
    4
    list1 = []
    def func(x):
        pass
    list2 = [func(value) for value in list1]  # list2里面是经过func处理过后的所有list1的值

8.元组

元组是一出生就不可以改变的列表。只能从中取值，不能改变它，不能复制它。可以用del语句删除整个元组。

注意：元组不可修改是指一级元素不可修改，二级元素可以修改。eg：（不过不建议，因为元组的设定就是不改变，要改变为什么不用list呢）

1
2
3
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
tu[1][2]["k2"].append("seven")
print(tu[1][2]["k2"])  # ['age', 'name', 'seven']

内置函数（可以直接调用的方法）

  • max(TUPLE)：TUPLE是元组，这样可以找到元组里最大值
  • min(TUPLE)：TUPLE是元组，这样可以找到元组里最小值
  • len(TUPLE)：TUPLE是元组，返回TUPLE的长度
  • sum(TUPLE, num)：TUPLE是数字元组，num是数字（默认为0），返回加完TUPLE后再加上num的值

方法

作为元组的唯二的两个方法：

  • count(obj)：返回obj元素在这个元组里的个数
  • index(obj)：返回这个obj在这个元组里的下标

9.字典

说明

字典中是键-值对，键不可重复，值可以重复，并且键可以是对象，值也可以是对象

基本操作

  • DICT = {}：创建一个空字典
  • DICT1 = DICT2：DICT1是DICT2的引用
  • DICT[key1] = val：DICT是字典。创建键值对的方法，__也是__更新值的方法
  • a = DICT[key1]：获取值的方法，若key1没有在字典中，报错。方便但不安全
  • del DICT[key1]：删除对应的键值对
  • del DICT：删除整个字典

内置函数（可以直接调用的方法）

  • len(DICT)：DICT是字典的名字，返回字典的键值对个数

方法

取键值：

  • items()：返回一个可遍历的键-值对元组数组
  • keys()：返回一个可遍历的键元组数组
  • values()：返回一个可遍历的值元组数组

注意：他们是不可以通过下标访问的，如果要用下标访问，需要转化成__列表__

数据结构用：

  • copy()：返回深拷贝的字典
  • get(key1)：返回键对应的值，如果没有返回None。安全但是方便
  • setdefault(key1)：和get()类似，这个是如果没有key1就添加key1键，并设置它的值为None
  • popitem()：返回并删除最后一个键值对
  • pop(key1)：返回并删除key1对应的值。没有key1会报错
  • clear()：清楚所有键值对

其他：

  • update(dict2)：将dict2里面的内容更新到调用该方法的字典中。会自动更新相同的键和添加不存在的键

更多方法见：Python 字典

10.集合

11.文件处理

​

-------------本文结束 感谢您的阅读-------------