Python笔记

牧码木

已于 2024-04-09 09:59:20 修改

阅读量664

点赞数 28

文章标签： python 笔记 java

于 2024-03-29 10:08:57 首次发布

本文链接：https://blog.csdn.net/weixin_47259638/article/details/137134973

版权

1、基本知识

1.1、值、类型、对象

1.1.1、值和类型

程序的数据是以值的形式体现的，值有对应的数据类型。Python中，可利用内置函数type()来查询一个值的数据类型；函数print()，在显示窗口输出内容。

例如：

2的数据类型是整数int

print(type(2))

输出结果

<class 'int'>

3.14的数据类型是浮点型float

print(type(3.14))

输出结果

<class 'float'>

hello,world的数据类型是字符串str

print(type('hello,world'))

输出结果

<class 'str'>

数据类型用来确认这个类型的值，占多大的内存，取值范围是多少，能够进行哪些运算(操作)。

例如：

int类型的值，可以是任意大的整数(只要计算机内存足够大)，可以进行加（+）、减（-）、乘（*）、除（/）、取余数（%）、整数除（//）等运算

加

print(5+2)

输出结果

减

print(2-5)

输出结果

-3

乘

print(5*2)

输出结果

除

print(5/2)

输出结果

2.5

取余数

print(5%2)

输出结果

整除

print(5//2)

输出结果

float类型的值，可以精确到15位小数点，可以进行加（+）、减（-）、乘（*）、除（/）、取余数（%）、整数除（//）等运算

加

print(5.1 + 2.2)

输出结果

7.3

减

print(5.1 - 2.2)

输出结果

2.8999999999999995

乘

print(5.1 * 2)

输出结果

10.2

除

print(5.1 / 2.2)

输出结果

2.318181818181818

取余数

print(5.1 % 2)

输出结果

1.0999999999999996

整除（float类型的值是转成整数类型进行的）

print(5.1 // 2)

输出结果

2.0

字符串str类型的值可以进行加（+）运算，但其含义是字符串拼接

例如：

print('hello' + 'world')

输出结果

helloworld

两个字符串str类型的值是不能进行减（-）、除（/）、乘（*）等运算

print('hello' - 'world')

会报TypeError(类型错误)

Traceback (most recent call last):
  File "C:/Users/PycharmProjects/Demo/demo.py", line 1, in <module>
    print('hello' - 'world')
TypeError: unsupported operand type(s) for -: 'str' and 'str'

但一个字符串str类型的值可以和一个整数int类型的值进行乘（*）运算，其结果是将字符串str类型的值复制整数int类型的值的次数，组成一个新的字符串str类型的值

print('hello' * 3)
print(3 * 'hello')

输出结果

hellohellohello
hellohellohello

1.1.2、对象

1、对象

每个值有具体内容和类型，计算机中表示这个值，需要给这个值分配一个独立的内存空间。在Python中，用对象来刻画有独立内存空间和数据类型的值。

一个对象包含：值、数据类型和id。每个对象都有唯一的id作为该对象的内存地址。在Python中，可以使用内置函数id()来查询一个对象的id。

print(id(3))
print(id(3.5))
print(id('hello'))

输出结果

1858759488
2535980671624
2535981368688

2、空值（None）

在Python中，有一个特殊的值None，称为空值，用来表示一个没有值的对象。

1.2、变量

1.2.1、变量的定义

像3、3.5、hello都是具体的值对象，而为了便于在程序代码中引用这些对象，可以给它们起名，这些名字就是变量，即：定义一个变量引用这个对象

定义的格式：
$变量名 = 对象$
等号=为赋值运算符，其含义是说明这个变量引用了哪个对象，而非真正的给这个变量一个值。

例：

a = 3
b = 3.5
c = 'hello'
print(a)
print(b)
print(c)

输出结果

3
3.5
hello

上述分别给3、3.5、hello起了不同的名称a、b、c，即定义了3个变量。

变量是对象的引用：变量本身不存储具体的数值，仅是对象的引用。可以用赋值运算符=修改变量引用的对象，使变量引用其他对象。

例：

a = 3
b = 3.5
print(a, b)
print(id(a), id(b))
# 将a引用的对象修改为b引用的对象
a = b
print(a, b)
print(id(a), id(b))

输出结果

3 3.5
1858759488 1807486362248
3.5 3.5
1807486362248 1807486362248

在这里插入图片描述

使用未定义的变量

print(name)

会报：NameError（名字错误）的错误

Traceback (most recent call last):
  File "C:/Users/PycharmProjects/Demo/demo.py", line 1, in <module>
    print(name)
NameError: name 'name' is not defined

1.2.2、运算符==和is

运算符==：用于比较对象的值是否相等

运算符is：用于判断两个对象是否为同一个

例：

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)
print(a is b)
print(id(a), id(b))

输出结果

True
False
2117829249224 2117829249160

True和Flase是bool(布尔)类型的两个值，分别表示“真”和“假”。上述a==b的结果为True，表明变量a引用对象的值和变量b引用对象的值相同；而a is b的结果为Flase，表明变量a引用的对象和变量b引用的对象不是同一个对象，从打印出来的内存地址来看，两个对象确实不是同一个。

注意：为了节省内存空间，Python会创建一个小整数池，范围是[-5,256]，当创建这个范围内的整数对象时，会直接从小整数池中获取已存在的对象，而不是重新分配内存，但这仅限于命令行模型下。而在Pycharm或保存文件执行时，用is比较结果不一样，这是因为解释器做了一部分优化，范围是[-5,任意正整数]

例：

命令行模式下执行

>>> a=-5
>>> b=-5
>>> print(a is b)
True
>>> a=-6
>>> b=-6
>>> print(a is b)
False
>>> a=256
>>> b=256
>>> print(a is b)
True
>>> b=257
>>> a=257
>>> print(a is b)
False
>>>

Pycharm下执行

a = -5
b = -5
print(a is b)
a = -6
b = -6
print(a is b)
a = 256
b = 256
print(a is b)
b = 257
a = 257
print(a is b)

执行结果

True
False
True
True

保存文件执行

 C:\Users\PycharmProjects\Demo 的目录

2024/03/04  11:23    <DIR>          .
2024/03/04  11:23    <DIR>          ..
2024/03/04  11:23    <DIR>          .idea
2024/03/04  11:23               144 demo.py
2024/02/22  17:20               544 main.py
2024/02/22  17:36    <DIR>          myProj
               2 个文件            688 字节
               4 个目录 58,152,902,656 可用字节

C:\Users\PycharmProjects\Demo>python demo.py
True
False
True
True

C:\Users\PycharmProjects\Demo>

对于字符串，不夹杂空格或其他符号时，Python会默认开启intern机制，共享内存，靠引用计数决定是否销毁。需要注意的是下划线也会开启intern机制。而在Pycharm或保存文件执行时，和整数一样，用is比较结果不一样。

例：命令行模式下执行

>>> a='hello'
>>> b='hello'
>>> print(a is b)
True
>>> a='he llo'
>>> b='he llo'
>>> print(a is b)
False
>>> a='he_llo'
>>> b='he_llo'
>>> print(a is b)
True
>>> a='he-llo'
>>> b='he-llo'
>>> print(a is b)
False
>>>

Pycharm下执行

a = 'hello'
b = 'hello'
print(a is b)
a = 'he llo'
b = 'he llo'
print(a is b)
a = 'he_llo'
b = 'he_llo'
print(a is b)
a = 'he-llo'
b = 'he-llo'
print(a is b)

执行结果

True
True
True
True

保存文件执行

 C:\Users\PycharmProjects\Demo 的目录

2024/03/04  11:37    <DIR>          .
2024/03/04  11:37    <DIR>          ..
2024/03/04  11:39    <DIR>          .idea
2024/03/04  11:37               186 demo.py
2024/02/22  17:20               544 main.py
2024/02/22  17:36    <DIR>          myProj
               2 个文件            730 字节
               4 个目录 58,143,023,104 可用字节

C:\Users\PycharmProjects\Demo>python demo.py
True
True
True
True

C:\Users\PycharmProjects\Demo>

1.2.3、变量名的命名规范

变量名只能包含字母、数字和下划线，且不能以数字开头

变量名不能和Python中的关键字相同，Python提供了一个keyword模块，可输出当前版本的所有关键字

例：

import keyword

print(keyword.kwlist)

执行结果

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

1.3、数据类型概述

Python自带了内在数据类型（内在类型），包括：数值（number）、字符串（str）、列表（list）、元组（tunple）、集合（set）、字典（dict）。

1.3.1、数值类型

数值类型不是单独的类型，可分为：整型（int）、浮点型（float）、复数类型（complex）、布尔类型（bool）。

整型（int）：只要内存足够，整型的长度就可以任意长；

浮点型（float）：小数点后的精度不超过15位；

复数类型（complex）：值总是写成x+yi的形式；

布尔类型（bool）：表示逻辑量，只有真（True）和假（False）两个值。

例：

# 整型（int）
a = 3
print(type(a))
# 浮点型（float）
b = 3.14
print(type(b))
# 复数类型（complex）
c = 2 + 3j
print(type(c))
# 布尔类型（bool）
d = True
print(type(d))

执行结果：

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'bool'>

1.3.2、列表（list）

列表（list）是一个数据元素的有序序列，列表（list）中的元素可以是不同类型的，当然也可以是列表（list）。定义列表（list）使用的是方括号[]。

例：

a = [1, 3.14, [2, 3, 4], 'hello']
print(type(a))

执行结果：

<class 'list'>

由于列表（list）是一个有序序列，每个元素都有唯一的下标，下标从0开始，所以，可以通过下标来获取列表（list）中的元素。

例：

a = [1, 3.14, [2, 3, 4], 'hello']
print(a[0])
print(a[1])
print(a[2])
print(a[3])

执行结果：

1
3.14
[2, 3, 4]
hello

同时，还可以通过下标来获取列表（list）中的子列表

例：

a = [1, 3.14, [2, 3, 4], 'hello', 9]
# 从第2个元素到第5个元素，不包含第5个元素
print(a[1:4])
# 从第3个元素到最后一个元素
print(a[2:])
# 从第1个元素到第5个元素，不包含第5个元素
print(a[:4])
# 没有起始下标和结束下标，表示所有元素
print(a[:])

执行结果：

[3.14, [2, 3, 4], 'hello']
[[2, 3, 4], 'hello', 9]
[1, 3.14, [2, 3, 4], 'hello']
[1, 3.14, [2, 3, 4], 'hello', 9]

列表（list）是可修改的，通过下标修改

例：

a = [1, 3.14, [2, 3, 4], 'hello', 9]
# 修改第3个元素的内容
a[2] = 2
print(a)

执行结果：

[1, 3.14, 2, 'hello', 9]

还可以给指定下标范围内的元素重新赋值，但重新赋的值必须是列表（list），否则会报错，如果赋值的是一个空列表[]，表示删除这个范围的元素。

例：

a = [1, 3.14, [2, 3, 4], 'hello', 9]
a[1:3] = [10, 11, 12, 13]
print(a)
a[1:5] = []
print(a)

执行结果：

[1, 10, 11, 12, 13, 'hello', 9]
[1, 'hello', 9]

1.3.3、元组（tuple）

元组（tuple）和列表（list）一样，也是一个有序序列，即元组（tuple）中的元素都有唯一的下标，但元组（tuple）中的元素无法修改，定义元组（tuple）使用的是圆括号（）。

例：

a = (1, 2, 3, [4, 5, 6], 7.89, 'hello')
print(type(a))

执行结果：

<class 'tuple'>

可以通过下标获取元组（tuple）中的元素

例：

a = (1, 2, 3, [4, 5, 6], 7.89, 'hello')
print(a[1])
print(a[3])
print(a[:3])
print(a[4:])
print(a[2:5])

执行结果：

2
[4, 5, 6]
(1, 2, 3)
(7.89, 'hello')
(3, [4, 5, 6], 7.89)

不可以通过下标修改元组（tuple）中的元素

例：

a = (1, 2, 3, [4, 5, 6], 7.89, 'hello')
a[1] = 5
print(a)

执行结果，报错：

Traceback (most recent call last):
  File "C:/Users/PycharmProjects/Demo/demo.py", line 2, in <module>
    a[1] = 5
TypeError: 'tuple' object does not support item assignment

注意，只有一个元素的元组（tuple），元素后必须加一个逗号，如（2，）表示元组（tuple），（2）表示一个整数

例：

a = (2,)
print(type(a))
b = (2)
print(type(b))

执行结果：

<class 'tuple'>
<class 'int'>

1.3.4、字符串（str）

字符串（str）也是一个有序序列，通过单引号或双引号包围一个字符序列来表示；

字符串（str）可以写在多行，通过三引号或双引号包围；

单引号表示的字符串可以包含双引号字符，但不能有单引号字符；

双引号表示的字符串可以包含单引号字符，但不能有双引号字符。

例：

a = 'hello'
print(a, type(a))
b = "hello"
print(b, type(b))
c = '''hello
    everyone
    !!!!
    '''
print(c, type(c))
d = 'hello"everybody"'
print(d, type(d))
e = "hello'everybody'"
print(e, type(e))

执行结果：

hello <class 'str'>
hello <class 'str'>
hello
    everyone
    !!!!
     <class 'str'>
hello"everybody" <class 'str'>
hello'everybody' <class 'str'>

和元组（tuple）一样，字符串（str）可以通过下标获取元素，但不能通过下标修改元素，字符串（str）类型的对象是不可修改的

通过下标获取元素

例：

a = 'hello'
print(a[1])
print(a[1:4])
print(a[1:])
print(a[:4])

执行结果：

e
ell
ello
hell

通过下标修改元素，会报错

例：

a = 'hello'
a[1] = 'b'

执行结果：

Traceback (most recent call last):
  File "C:/Users/PycharmProjects/Demo/demo.py", line 2, in <module>
    a[1] = 'b'
TypeError: 'str' object does not support item assignment

转义字符：如果需要在单引号表示的字符串中包含单引号，需要在单引号前面加上\，\'就是转义字符。

例：

# 单引号的字符串中包含单引号
a = 'he\'llo'
print(a)
# \\表示单个斜杠字符\
b = 'he\\llo'
print(b)
# \t表示制表符
c = 'he\tllo'
print(c)
# \n表示换行符
d = 'he\nllo'
print(d)

执行结果：

he'llo
he\llo
he	llo
he
llo

1.3.5、集合（set）

集合（set）是不包含重复元素的无序集合，定义使用花括号{}，由于是无序的，所以集合（set）无法通过下标来获取元素。

例：

s = {
   1, 2, 3, 3.14, 'hello'}
print(s)
print(type(s))
# 集合（set）元素不重复
s1 = {
   1, 2, 3, 3, 3.14, 3.14, 'hello', 'hello'}
print(s1)
print(type(s1))

执行结果：

{
   1, 2, 3.14, 3, 'hello'}
<class 'set'>
{
   1, 2, 3.14, 3, 'hello'}
<class 'set'>

集合（set）是根据元素的哈希值存储元素的，而列表（list）对象无法计算哈希值，所以列表（list）不能作为集合（set）的元素

例：

集合（set）中存储列表（list），会报错

s = {
   [1, 2, 3], 3.14, 'hello'}
print(s)

执行结果：

raceback (most recent call last):
  File "C:/Users/PycharmProjects/Demo/demo.py", line 1, in <module>
    s = {
   [1, 2, 3], 3.14, 'hello'}
TypeError: unhashable type: 'list'

1.3.6、字典（dict）

字典（dict）是一个键：值（key：value）对的无序集合，每个元素都是以键：值（key：value）的形式存储的

例：

d = {
   'name': 'zhang_san', 'age': 18}
print(d)
print(type(d))

执行结果：

{
   'name': 'zhang_san', 'age': 18}
<class 'dict'>

字典（dict）通过键（key）获取对应的值（value）

例：

d = {
   'name': 'zhang_san', 'age': 18}
print(d['name'])

执行结果：

{
   'name': 'zhang_san', 'age': 18}
<class 'dict'>

1.4、类型转换

1.4.1、隐式类型转换

某些情况下，Python会自动将一个类型转换成为另一个类型，这种就是隐式类型转换

例：

整数和浮点数运算时，整数会被自动转换成浮点数

# 整数和浮点数运算时，整数会被自动转换成浮点数
a = 2
b = 3.14
c = a + b
print(type(a), a)
print(type(b), b)
print(type(c), c)

执行结果

<class 'int'> 2
<class 'float'> 3.14
<class 'float'> 5.140000000000001

两个整数相除，也会自动转换成浮点数相除

# 两个整数相除，也会自动转换成浮点数相除
a = 5
b = 2
c = a / b
print(type(a), a)
print(type(b), b)
print(type(c), c)

执行结果

<class 'int'> 5
<class 'int'> 2
<class 'float'> 2.5

1.4.2、显式类型转换

通过Python的内置函数进行显式类型转换

函数str（）可以将数值类型（int、float、complex）的值转换成字符串类型（str）

例：

a = 30
a_str = str(a)
b = 3.14
b_str = str(b)
c = 2 + 3j
c_str = str(c)
print(type(a_str), a_str)
print(type(b_str), b_str)
print(type(c_str), c_str)

执行结果：

<class 'str'> 30
<class 'str'> 3.14
<class 'str'> (2+3j)

函数int（）可以将一个合适格式的字符串类型的值或浮点（float）类型的值转换成整数（int）类型的值，浮点类型的值转换时，小数点后的数会被截断

例：

a_str = '30'
print(type(a_str), a_str)
a = int(a_str)
print(type(a), a)
b_float = 3.14
print(type(b_float), b_float)
b = int(b_float)
print(type(b), b)

执行结果：

<class 'str'> 30
<class 'int'> 30
<class 'float'> 3.14
<class 'int'> 3

函数float（）可以将一个合适格式的字符串类型的值或整数（int）类型的值转换成浮点（float）类型的值

例：

a_str = '30'
print(type(a_str), a_str)
a = float(a_str)
print(type(a), a)
b_int = 3
print(type(b_int), b_int)
b = float(b_int)
print(type(b), b)

执行结果

<class 'str'> 30
<class 'float'> 30.0
<class 'int'> 3
<class 'float'> 3.0

1.5、输入

内置函数input()：从键盘输入数据

格式：
$in p u t (^{'} 描述内容：^{'})$
例：

msg = input('请输入内容:')
print(type(msg), msg)

执行结果

请输入内容:30
<class 'str'> 30

函数input()返回的是一个字符串类型的值

1.6、运算符

1.6.1、基本概念

运算符：表示不同运算功能的特殊符号，例：+（加）、-（减）、*（乘）、/（除）等

运算数：运算符操作的变量或值，

表达式：用+（加）、-（减）、*（乘）、/（除）这些运算符对运算数进行运算的式子，表达式由运算符和运算数组成

例：

2+3

上例中，+为运算符，2和3为运算数，2+3为表达式

1.6.2、运算符的种类

Python有不同功能的各种运算符，例：进行数学计算的算术运算符，比较2个运算数大小的比较运算符，进行逻辑运算的逻辑运算符，对二进制位进行操作的二进制运算符，对变量赋值的赋值运算符等

1、算术运算符

下表为算术运算符的含义和示例
在这里插入图片描述

2、比较运算符

下表是比较运算符的含义和示例

对两个量进行比较，产生的结果是布尔类型（bool）的值（真(True)或假(False)）
在这里插入图片描述

3、逻辑运算符

下表是逻辑运算符的含义和示例
在这里插入图片描述

在逻辑运算符中，True、非0或非空对象就是真（True），而Flase、0或空对象就是假（False）

当一个对象x为真时，not x 就是False，x为假时，not x 就是True

例：

# 对象为真(True、非0、非空对象)时
print(not True)
print(not 2)
print

最低0.47元/天解锁文章

牧码木

关注

28
点赞
踩
28

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫