python基础语法

最新推荐文章于 2023-05-19 09:55:02 发布

Popuil

最新推荐文章于 2023-05-19 09:55:02 发布

阅读量259

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/qq_35547417/article/details/126348870

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

基础语法[持续学习更新中]

1. 变量类型
2. 逻辑语句
3. 类
- Python内置类属性
4. 错误和异常

1. 变量类型

数字
字符串
字符串可以看做是字符的列表，不存在字符类型，包含一个字符的也称作字符串
创建字符串可以用单引号也可以用双引号

原始字符串
当字符串中出现转义字符时，可以在字符串前面加 r 或 R，就不会打印转义后的结果，只会按照字符串的内容打印
print(r’das\nasd’\n’) das\nasd’\n

使用三引号可以使字符串按照多行输出

print('''大
大声道
dasdas
das''')   

输出：
大
大声道
dasdas
das

使用运算符对字符串进行操作
+ 连接两个字符串
* 对字符串进行重复

字符串的查操作
提供四种方法查找指定字符串的索引 index, find,(从前往后查找) rfind, rindex（从后往前查找）

print(sr.index('dw'))        3
print(sr.find('dw'))         3
print(sr.rfind('dw'))        6
print(sr.rindex('dw'))        6

字符串没有增，改，删操作，因为字符串是不可变类型

比较运算符可以用来比较字符串 >, >=, <, <=, ==, !=
比较字符串是比较每个字符的ascii值，内置函数ord()可以获得字符的ascii值，chr()可以把ascii码转换成整型
print(ord(‘a’)) 97
print(chr(49)) 1

字符串的翻转
内置函数 reversed() ，且返回的reversed对象，只能用列表来展示，与列表不同的是，列表是可变的，可调用方法reverse
sr = ‘dasqdwqc’
st = reversed(sr)
print(st) <reversed object at 0x0000023CB74A1160>
print(list(st)) [‘c’, ‘q’, ‘w’, ‘d’, ‘q’, ‘s’, ‘a’, ‘d’]

字符串的排序
因为不可变，只能调用内置函数sorted()
sr = ‘hekodas’
print(sorted(sr)) [‘a’, ‘d’, ‘e’, ‘h’, ‘k’, ‘o’, ‘s’]

sorted()还可以指定函数来进行排序，只要将key指定某个方法即可
sr = ‘aBDeT’
print(sorted(sr)) [‘B’, ‘D’, ‘T’, ‘a’, ‘e’]
print(sorted(sr,key=str.lower)) [‘a’, ‘B’, ‘D’, ‘e’, ‘T’] lower可以先将字符转换成小写再进行排序

格式化字符串
使用百分号
s = ‘my age is %d\n’ % 16
print(s) my age is 16

调用方法format,并使用花括号作为占位符，从而得到格式化字符串
book = ‘花’
print(‘我喜欢{}’.format(book)) 我喜欢花

还可以在花括号中使用位置参数来匹配format中的参数，也可以使用关键字参数
price = 100
book = ‘<数据结构>’
print(‘小明花了{0}元，买了一本书:{1}，一共花了{0}元’.format(price,book)) 小明花了100元，买了一本书:<数据结构>，一共花了100元

price = 100
print(‘我有{p}元’.format(p=price)) 我有100元

占位符中可以使用冒号来指定整数的表现形式，比如十进制，十六进制等 {:d} 10进制 {:b}2进制
print(‘{:x}’.format(110)) 6e

字符串的内建函数
string.capitalize()
把字符串的第一个字符大写
string.center(width)
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding=‘UTF-8’, errors=‘strict’)
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 ‘ignore’ 或者’replace’
string.encode(encoding=‘UTF-8’, errors=‘strict’)
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
string.endswith(obj, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()
格式化字符串
string.index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()
如果 string 至少有一个字符并且所有字符都是字母或数字则返
回 True,否则返回 False
string.isalpha()
如果 string 至少有一个字符并且所有字符都是字母则返回 True,
否则返回 False
string.isdecimal()
如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()
如果 string 只包含数字则返回 True 否则返回 False.
string.islower()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()
如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()
如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()
如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()
转换 string 中所有大写字符为小写.
string.lstrip()
截掉 string 左边的空格
string.maketrans(intab, outtab])
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)
返回字符串 str 中最大的字母。
min(str)
返回字符串 str 中最小的字母。
string.partition(str)
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串 string 分成一个 3 元素的元组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )
类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.rindex( str, beg=0,end=len(string))
类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。
string.rjust(width)
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)
类似于 partition()函数,不过是从右边开始查找
string.rstrip()
删除 string 字符串末尾的空格.
string.split(str=“”, num=string.count(str))
以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.splitlines([keepends])
按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])
在 string 上执行 lstrip()和 rstrip()
string.swapcase()
翻转 string 中的大小写
string.title()
返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del=“”)
根据 str 给出的表(包含 256 个字符)转换 string 的字符,
要过滤掉的字符放到 del 参数中
string.upper()
转换 string 中的小写字母为大写
string.zfill(width)
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

对齐：
print(“hello”.center(10)) hello
print(“hello”.center(10,'')) hello

L = “hello”.ljust(6,'')
print(L,len(L)) hello 6

替换：
s = ‘he-he-he’
print(s.replace(‘he’,‘hi’,2)) he-he-he

合并和断开：
s = ‘fe fewf eff’
print(s.split()) [‘fe’, ‘fewf’, ‘eff’] 默认以空格去断开
print(s.rsplit()) [‘fe’, ‘fewf’, ‘eff’]
print(s.split(sep=‘e’)) [‘f’, ’ f’, ‘wf ‘, ‘ff’]
print(’|’.join([‘1’,‘2’,‘3’])) 1|2|3

元组
列表
字典
集合
数据类型
- 内置函数type可以获取数据类型 type(8) print(type(1)) = <class ‘int’> print(type(‘w’)) = <class ‘str’>
  类型详解
  整数类型：十进制默认
  二进制：以0b开头 0b11 = 3
  八进制：以0o开头 0o11 = 9
  十六进制：以0x开头
- 整数与字符串的转换
  bin() 将十进制数转换成2进制字符串 bin(1) = 0b1
  oct() 将十进制数转换成8进制字符串
  hex() 将十进制数转换成16进制字符串
  print(bin(1)) 0b1
  print(oct(3)) 0o3
  print(hex(3)) 0x3
- 整数创建：默认给值或者用内置函数int()创建
  传递一个参数时默认为整型，传递两个参数时，第一个参数为字符串第二个参数指定进制
  print(int(118)) 118
  print(int(118.2)) 118
  print(int(‘118’)) 118
  print(int(‘118’,16)) 280
  print(int(‘0x118’,16)) 280
  print(int(‘0x118’)) 无效写法
- 浮点数的创建
  内置函数float()进行创建：
  不传递参数时默认为0.0
  传递一个参数时自动转换成浮点数
  print(float()) 0.0
  print(float(10)) 10.0
  print(float(10.1)) 10.1
  print(“10”) 10
- 科学技术法表示浮点数
  print(float(10e2)) 1000.0
  print(float(10e-2)) 0.1
- 浮点数计算的不精确性
  计算机是二进制存储的，浮点数所以是不精确的
  print(1.1 + 2.2) 3.3000000000000003
所以我们可以利用decimal模块处理十进制的浮点数。或者使用fractions处理分数
from decimal import Decimal
print(Decimal(‘1.1’) + Decimal(‘2.2’)) 3.3

from fractions import Fraction
print(Fraction(11,10) + Fraction(22,10)) 33/10

布尔类型
print(True) True
print(False) False
print(4 > 3) True
运算符

2. 逻辑语句

3. 类

Python内置类属性

dict : 类的属性（包含一个字典，由类的数据属性组成）
doc :类的文档字符串
name: 类名
module: 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
bases : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
str: print（实例）的时候返回你指定的字符串

class Employee:
    '所有员工的基类'
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1
  
    def __str__(self):
        return "test for Emplpyee"

    def displayCount(self):
        print("Total Employee %d" % Employee.empCount)

    def displayEmployee(self):
        print("Name : ", self.name,  ", Salary: ", self.salary) 


if __name__ == '__main__':
 
    A = Employee('bob',100)

    print("Employee.__doc__:", Employee.__doc__) 
    print("Employee.__name__:", Employee.__name__) 
    print("Employee.__module__:", Employee.__module__) 
    print("Employee.__bases__:", Employee.__bases__) 
    print("Employee.__dict__:", Employee.__dict__) 
    print("Employee.__str__:",Employee)
    print("Employee.__str__:",A)

输出:

Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {'__module__': '__main__', '__doc__': '所有员工的基类', 'empCount': 1, '__init__': <function Employee.__init__ at 0x0000015B07CED550>, '__str__': <function Employee.__str__ at 0x0000015B07CED5E0>, 'displayCount': <function Employee.displayCount at 0x0000015B07CED670>, 'displayEmployee': <function Employee.displayEmployee at 0x0000015B07CED700>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>}
Employee.__str__: <class '__main__.Employee'>
Employee.__str__: test for Emplpyee

4. 错误和异常

语句介绍
当程序运行时，抛出异常可以被程序捕捉，异常捕捉可以使用 try/except 语句。

try:
执行的语句块
expect:
发生异常时执行代码块
else:
没有异常执行的代码
finally
不管有没有异常都会执行的代码块

    try:
        f = open("test.txt", 'r')
    except IOError:
        print('cannot open')
    else:
        print('open success')
        f.close()
    finally:
        print("always enter")

输出：

cannot open
always enter

常见的异常类型如下

异常名称	类型描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python
NameError	未声明/初始化对象
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python
IndentationError	缩进错误
TabError	Tab
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode
UnicodeDecodeError	Unicode
UnicodeEncodeError	Unicode
UnicodeTranslateError	Unicode
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime）
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

抛出异常
Python 使用 raise 语句抛出一个指定的异常。
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

    x = 5

    try:
        if x > 1:
            raise Exception	
    except Exception:
        print('raise error')

输出：

raise error

用户自定义异常:
可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

class MyError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

if __name__ == '__main__':
    try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)