Python从拿起到放下(入门篇)

本系列文章纯干货，无乱七八糟闲言碎语。

关键字

1
2
3
4
5
6
True 
Flase 
None 
is 
not 
del ......

表达式与运算符

表达式

  • 赋值语句
    变量 = 表达式 

    1
    2
    3
    4
    5
    a = 2
    b = 1 + 1
    d = e = f = 100
    g, h, i = 1, 2, 3

  • is/is not表达式
    变量定义接上述代码

    1
    2
    3
    4
    print(a is b)
    print(d is e)
    print(b is d)

    结果： 

    1
    2
    3
    True
    True
    False

  • id(x)
    获取某个变量的id

  • del
    删除变量 del a

比较运算符

< <= > >= == != 返回Bool类型

数值对象的构造函数

  • float(obj) 将字符串或者数字转换为浮点数。 
    1
    2
    3
    b = 2
    fb = float(b)
    print(fb)
    输出：
    2.0
    其他类型转换：
  • int(x=0,base=0)
    如：int('101010111',2)表示将二进制的101010111字符串转换为10进制数字输出。
    若参数为空，则输出0，无法转换则报异常。
  • complex(r=0.0,i=0.0)
    用数字创建一个复数。
  • bool(x)
    创建一个bool类型的值。

内置函数

  • abs(x)
    取绝对值。
  • round(number,digits)
    四舍五入，其中digits为正数小数点右边取舍的位数，若为负数则小数点左边舍去的位数。
    如： 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #注意
    print(round(4.4), round(4.5))
    print(round(4.4), round(4.51))

    print(round(4.14, 0), round(4.15, 0))
    print(round(4.14, 1), round(4.15, 1))
    print(round(4.14, 2), round(4.15, 2))

    #注意
    print(round(14.14, -1), round(114.15, -2))
    结果： 
    1
    2
    3
    4
    5
    6
    4 4
    4 5
    4.0 4.0
    4.1 4.2
    4.14 4.15
    10.0 100.0
    注意：四舍五入，需要大于5才进位，等于5不进位。
  • power(x,y,z=None)
    等价于x**y或者x**y%z
  • help(函数名)
    查看函数的帮助文档。
    如：help(pow) 
    1
    2
    3
    4
    5
    6
    7
    Help on built-in function pow in module builtins:

    pow(x, y, z=None, /)
        Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
        
        Some types, such as ints, are able to use a more efficient algorithm when
        invoked using the three argument form.

语句

语句是python可执行的最小单位，可以独立执行。

换行

多条语句一行执行，需要以;隔开，通常一条语句一行，复合语句除外。

  • 折行符\换行
    \折行符反斜杠表示：告诉解析器，下一行的内容也是该行的内容。
  • 隐式换行
    所有括号的内容换行时候，解析器会自动去下一行找相应的内容，直到找到为止。

输入输出

  • 输入input
    其中，input中的提示语为可选。 
    1
    2
    x = input("input something,and enter exit.\n")
    print(x+'\n')
    结果：
    1
    2
    3
    input something,and enter exit.
    asd
    asd
  • 输入print
    格式： print(value,...,sep='',end='')
    其中sep为分隔符，end为结束字符串，默认为\n。

分支语句

  • if-elif…else语句

    自上而下判断，如果有一条语句为True，则结束分支执行，如果所有真值表达式都为False，则执行else中的语句。
    elif子语句可以有0、1、多个
    else语句可以有0、1个

    且if-elif…else语句可以嵌套

    如下：判断一个整数是正数、负数、还是0 
    1
    2
    3
    4
    5
    6
    7
    num = int(input())
    if num > 0:
        print("正数")
    elif num < 0:
        print("负数")
    else:
        print("零")
    判断一个数字是偶数还是奇数 
    1
    2
    3
    4
    5
    6
    # 判断一个数字是偶数还是奇数
    num2 = int(input())
    if num2 % 2 == 0:
        print("偶数")
    else:
        print("奇数")

pass语句

作用：通常用来填充语法空白。
如：将一个数字转换为它的绝对值。 

1
2
3
4
5
6
num3 = int(input())
if num3 >=0:
    pass
else:
    num3 = -num3
print(num3)

如果我们不写pass填充语法空白，那么程序将会编译错误。

布尔运算

  • not
    not x，对x进行布尔取非，即先判断x的bool值，然后对取非
    如： 
    1
    2
    3
    4
    5
    x = True
    y = 2
    z = 0
    print(x, y, z)
    print(not x, not y,not z)
    结果： 
    1
    2
    True 2 0  
    False False True
  • and
    x and y，对x、y取与运算，从左到右判断，若遇到False，则返回False。如果都为True，则返回True。
    如： 
    1
    2
    3
    4
    5
    6
    x = True
    y = False
    z = True
    print(x and y)
    print(x and z)
    print(y and z)
    结果： 
    1
    2
    3
    False
    True
    False
  • or
    x or y，对x、y取或运算，从左到右判断，若遇到True，则返回True。如果都为False，则返回False。
    如： 
    1
    2
    3
    4
    5
    6
    x = False
    y = True
    z = False
    print(x or y)
    print(x or z)
    print(y or z)
    结果： 
    1
    2
    3
    True
    False
    True

正负号运算符

  • +
  • -

真值表达式赋值


如上图，该语句由三个子语句表达式构成，如果前面两个子语句成立，则返回第一个子语句，否则返回第三个子语句。 

1
2
5
9

字符串

用单引号'、双引号"、三单引号'''、三双引号"""括起来的都是字符串，用来记录文本信息。

  • 空字符串表示 

    1
    2
    3
    4
    ''
    ""
    ''''''
    """"""

  • 非空字符串表示 

    1
    2
    3
    4
    'hello'
    "hello"
    '''hello'''
    """hello """

  • 单引号和双引号的作用（三单引号和三双引号同样适用）
    单引号内的双引号不算开始符、结束符
    双引号内的单引号也不算开始符、结束符
    二者均作为文本的一部分 

    1
    2
    3
    4
    s1 = 'abcd"e"'
    s2 = "abcd'e'"
    print(s1)
    print(s2)

    结果： 

    1
    2
    abcd"e" 7
    abcd'e' 7

  • 三双引号可以保留输入文本的原格式
    允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下: 

    1
    2
    3
    4
    5
    6
    7
    8
    #!/usr/bin/python3
     
    para_str = """这是一个多行字符串的实例
    多行字符串可以使用制表符
    TAB ( \t )。
    也可以使用换行符 [ \n ]。
    """
    print (para_str)

    以上实例执行结果为： 

    1
    2
    3
    4
    5
    这是一个多行字符串的实例
    多行字符串可以使用制表符
    TAB (    )。
    也可以使用换行符 [ 
     ]。

    三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

  • 隐式字符串
    隐式字符串字面值会进行拼接，如： 

    1
    2
    s = "1" '2' '''3''' """4"""
    print(s)

    结果： 

    1
    1234

  • 转义字符\
    如：\'表示 一个单引号，其他的如下：

    转义字符 描述
    \(在行尾时) 续行符
    \\ 反斜杠符号
    \' 单引号
    \" 双引号
    \n 换行
    \a 响铃
    \b 退格(Backspace)
    \e 转义
    \000 空
    \0 字符串，值为0
    \n 换行
    \v 纵向制表符
    \t 横向制表符
    \r 回车
    \f 换页
    \oyy 八进制数，yy代表的字符，例如：\o12代表换行
    \xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
    \xXX XX为两位16进制字符
    \uXXXX Unicode16
    \UXXXXXXXX Unicode32
    \other 其它的字符以普通格式输出

  • 原生字符串raw
    \字符不进行转义，怎么显示，怎么输出。
    格式：r"字符串"。 

    1
    2
    3
    4
    s1 = "1\t234"
    print(s1)
    s2 = r"1\t234"
    print(s2)

    输出： 

    1
    2
    1   234
    1\t234

  • 字符串拼接
    + 拼接
    += 拼接加
    *数字n 重复拼接n次
    *=

  • 字符串比较 

    1
    2
    3
    4
    5
    6
    >
    >=
    <
    <=
    ==
    !=

    格式：
    x > y
    比较规则：

    1. 字符串x的第一个字母与y的第一个字母比较，如果不相同，则直接得出比较结果；如果相同，则再取第二个字母进行比较，以此类推。
    2. 比较的依据是字符的unicode编码值。
      如： 
      1
      2
      3
      4
      print("a">"b")
      print("a">"A")
      print("abc">"ab")
      print("abc">"acb")
      结果： 
      1
      2
      3
      4
      False
      True
      True
      False

  • in not in 运算符
    用于在字典、集合、序列等容器中，判断某个值是否存在。
    格式：对象 in 序列
    如： 

    1
    2
    3
    print("a" in 'abc')
    print("a" in 'bcd')
    print('a' not in "abc")

    结果： 

    1
    2
    3
    True
    False
    False

  • 字符串索引index
    python的字符串是不可以改变的字符序列。
    语法： 字符串[整数表达式]
    说明：

    python中的序列都可以用索引来访问其中的对象。
    正向索引下标从0开始，第二个是1，最后一个是len(s)-1。
    反向索引下标从-1开始，-1代表最后一个，-2代表倒数第二个，第一个是-len(s)

    如： 

    1
    2
    s = "hello world!"
    print(s[0], s[1], s[-1], s[-2], s[-len(s)], s[len(s) - 1], sep="\n")

    结果：

    1
    2
    3
    4
    5
    6
    h
    e
    !
    d
    h
    !

    注意：如果超出下标，则报下标越界异常。

  • 切片 slice
    从字符串序列中取出相应的元素，重新组成一个字符串序列。
    语法：字符串[开始索引:结束索引:(步长，可选)]
    说明：

    1. 开始切片是切片切下的位置，0代表第一个元素、1为第二个元素、-1代表最后一个元素，默认是第一个元素。
    2. 结束索引是切片的终止索引，但不包括终止点，默认是最后一个元素。
    3. 步长是切片每次获取完当前元素后向右移动索引的跨度，默认为1，步长为正数时，正向切片，步长为复数时，反向切片。

    如： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    s = "hello world!"
    # 打印字符串1-最后一位
    print(s[1:len(s)])
    # 打印字符串0-最后一位
    print(s[0:len(s)])
    # 打印字符串0-最后一位，步长为2
    print(s[0:len(s):2])
    # 反向打印字符串，步长分别为1和2
    print(s[-1:-len(s) - 1:-1])
    print(s[-1:-len(s) - 1:-2])

    结果：

  • 返回序列的最值

    1. max(x)
    2. min(x)

  • 编码转换

    1. ord(c) 返回unicode
    2. chr(i) 返回i(0-65535)这个值对应的字符

    如： 

    1
    2
    print(ord("浩"))
    print(chr(28009))

    结果： 

    1
    2
    28009
    浩

  • 数字转换为字符串函数

    1. hex(i)
    2. oct(i)
    3. bin(i)

  • 表达式判断补充 

    1
    2
    3
    4
    a = 3
    b = 1
    c = 2
    print(b < a > c)

    结果：Ture

  • 判断是否是回文字符串
    回文即对称的字符串，如1221、12321。
    思路一：正向取字符串的前一半，然后反向取字符串的后一半，判断二者是否相等，如果相等，则为回文字符串。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    s = "上海自来水来自海上"
    i = 0
    # 偶数，取长度/2个字符串
    if (len(s) % 2) == 0:
        i = len(s) // 2
    # 奇数，取长度/2+1个字符串
    else:
        i = len(s) // 2 + 1
    s1 = s[0:i]
    s2 = s[-1:-i - 1:-1]
    print(s1, s2, sep="\n")
    print(s1 == s2)

    结果： 

    1
    2
    3
    上海自来水
    上海自来水
    True

    思路二：将字符串反向输出，然后和原字符串比较，是否相等，如果相等则为回文字符串。

  • 字符串运算符整理
    下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

    操作符 描述 实例
    + 字符串连接 >>>a + b
    'HelloPython'
    * 重复输出字符串 >>>a * 2
    'HelloHello'
    [] 通过索引获取字符串中字符 >>>a[1]
    'e'
    [:] 截取字符串中的一部分，左闭右开区间 >>>a[1:4]
    'ell'
    in 成员运算符-如果字符串中包含给定的字符返回True >>>"H" in a
    True
    not in 成员运算符-如果字符串中不包含给定的字符返回True >>>"M" not in a
    True
    r/R 原始字符串-原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 >>>print r'\n'
    \n
    >>> print R'\n'
    \n

    具体示例如下： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    a = "Hello"
    b = "Python"

    print("a + b 输出结果：", a + b)
    print("a * 2 输出结果：", a * 2)
    print("a[1] 输出结果：", a[1])
    print("a[1:4] 输出结果：", a[1:4])
    if "H" in a:
        print("H 在变量 a 中")
    else:
        print("H 不在变量 a 中")

    if "M" not in a:
        print("M 不在变量 a 中")
    else:
        print("M 在变量 a 中")

    print(r'\n')
    print(R'\n')

    以上程序执行结果为： 

    1
    2
    3
    4
    5
    6
    7
    8
    a + b 输出结果： HelloPython
    a * 2 输出结果： HelloHello
    a[1] 输出结果： e
    a[1:4] 输出结果： ell
    H 在变量 a 中
    M 不在变量 a 中
    \n
    \n

  • 字符串格式化
    Python支持格式化字符串的输出。在Python中，字符串格式化使用与C语言函数一样的语法。
    如： 

    1
    print("I am %s,and I am %d years old." % ("leehao", 23))

    输出结果为： 

    1
    I am leehao,and I am 23 years old.

    python 字符串格式化符号:

    符 号 描述
    %c 格式化字符及其ASCII码
    %s 格式化字符串
    %d 格式化整数
    %u 格式化无符号整型
    %o 格式化无符号八进制数
    %x 格式化无符号十六进制数
    %X 格式化无符号十六进制数（大写）
    %f 格式化浮点数字，可指定小数点后的精度
    %e 用科学计数法格式化浮点数
    %E 作用同%e，用科学计数法格式化浮点数
    %g %f和%e的简写
    %G %F和%E的简写
    %p 用十六进制数格式化变量的地址

    格式化操作符辅助指令:

    符号 功能
    * 定义宽度或者小数点精度
    - 用做左对齐
    + 在正数前面显示加号(+)
    <sp> 在正数前面显示空格
    # 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
    0 显示的数字前面填充'0'而不是默认的空格
    % '%%'输出一个单一的'%'
    (var) 映射变量(字典参数)
    m.n. m是显示的最小总宽度,n是小数点后的位数(如果可用的话)

    示例如下： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    # %c 格式化字符及其ASCII码 范围0~0x110000
    print("%c" % 0x55)
    # % s 格式化字符串
    print("i am %s" % "leehao")
    # % d 格式化整数
    print("i am %d years old." % 23)
    # % u 格式化无符号整型 2.7以后的版本%u同%d
    print("the number is %u ." % -23)
    # % o 格式化无符号八进制数
    print("the number %d is %o in 8th" % (23, 23))
    # % x 格式化无符号十六进制数
    print("the number %d is %x in 16th" % (23, 23))
    # % X 格式化无符号十六进制数（大写）
    print("the number %d is %X in 16th" % (23, 23))
    # % f 格式化浮点数字，可指定小数点后的精度,'.2'表示小数点后2位
    print("the number is %.2f " % 123.457)
    # % e 用科学计数法格式化浮点数，其中'.2'表示小数点后精度为2
    print("the number is %.2e " % 123.457)
    # % E 作用同 % e，用科学计数法格式化浮点数
    print("the number is %.3E " % 123.457)
    # % G、% g 。根据值的大小采用%e或%f，但最多保留6位有效数字
    print("the number is %g" % 2123.459987)
    # % p   用十六进制数格式化变量的地址 0x70

    上述程序运行结果如下： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    U
    i am leehao
    i am 23 years old.
    the number is -23 .
    the number 23 is 27 in 8th
    the number 23 is 17 in 16th
    the number 23 is 17 in 16th
    the number is 123.46 
    the number is 1.23e+02 
    the number is 1.235E+02 
    the number is 2123.46

  • f-string
    f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
    f-string 格式话字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去。
    用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
    在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果。
    如下： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    name = 'Runoob'
    s1 = f'Hello {name}'
    print(s1)

    s2 = f'{1 + 2}'
    print(s2)

    w = {'name': 'Runoob', 'url': 'www.runoob.com'}
    s3 = f'{w["name"]}:{w["url"]}'
    print(s3)

    x = 1
    print(f'{x+1}')   # Python 3.6
    print(f'{x+1=}')   # Python 3.8

    上述程序运行结果如下： 

    1
    2
    3
    4
    5
    6
    Hello Runoob
    3
    Runoob:www.runoob.com
    2
    x+1=2

Python
#python
Python从拿起到放下(入门篇)
https://leehoward.cn/2019/11/24/Python从拿起到放下(入门篇)/
作者
lihao
发布于
2019年11月24日
许可协议