初学者必看Python基础入门 基础语法和变量类型_python基础语法和变量类型

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注软件测试）

正文

另外，我们也可以同一行显示多条语句，语句之间用分号(;)分割，示例如下：

print(‘Hello’);print(‘world’)
复制代码

对于用户输入，Python2 采用的是 raw_input()，而 3 版本则是 input() 函数：

等待用户输入

python 2

user_input = raw_input(‘请输入一个数字:\n’)

python 3

user_input = input(‘请输入一个数字:\n’)
print(‘user_input=’, user_input)
复制代码

其中 \n 实现换行。用户按下回车键(enter)退出，其他键显示。

对于 print 输出，默认输出是换行的，如果需要实现不换行，可以指定参数 end，如下所示：

a = 3
b = 2
c = 4
d = 5

默认换行

print(a)
print(b)

不换行，并设置逗号分隔

print(c, end=‘,’)
print(d)
复制代码

二 基本变量类型

计算机程序要处理不同的数据，需要定义不同的数据类型。Python 定义了六种标准的数据类型，分布如下所示：

• Numbers(数字)
• Strings(字符串)
• List(列表)
• Tuple(元组)
• Set(集合)
• Dictionary(字典)

变量赋值

Python 并不需要声明变量的类型，所说的"类型"是变量所指的内存中对象的类型。但每个变量使用前都必须赋值，然后才会创建变量。给变量赋值的方法是采用等号(=)，等号左边是变量名，右边是存储在变量中的值。

一个示例如下：

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = “John” # 字符串

print(counter)
print(miles)
print(name)
复制代码

Python 还允许同时为多个变量赋值，有以下两种实现方式：

创建一个整型对象，值为1，三个变量被分配到相同的内存空间上

n = m = k = 2

创建多个对象，然后指定多个变量

cc, mm, nn = 1, 3.2, ‘abc’

print(‘n=m=k=’, n, m, k)
print(‘cc=’, cc)
print(‘mm=’, mm)
print(‘nn=’, nn)
复制代码

其中同时给多个变量赋值的方式也是 Python 独特的一种变量赋值方法。

数字

数字类型用于存储数值，它是不可改变的数据类型。Python 3 支持以下几种数字类型：

• int (整数)
• float (浮点型)
• complex(复数)
• bool (布尔)

数字类型的使用很简单，也很直观，如下所示：

int

q = 1

float

w = 2.3

bool

e = True

complex

r = 1 + 3j
print(q, w, e, r) # 1 2.3 True (1+3j)

内置的 type() 函数可以用来查询变量所指的对象类型

print(type(q)) # <class ‘int’>
print(type(w)) # <class ‘float’>
print(type(e)) # <class ‘bool’>
print(type®) # <class ‘complex’>

也可以采用 isinstance()

isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型

print(isinstance(q, int)) # True
print(isinstance(q, float)) # False
复制代码

对于数字的运算，包括基本的加减乘除，其中除法包含两个运算符，/ 返回一个浮点数，而 // 则是得到整数，去掉小数点后的数值。而且在混合计算的时候， Python 会把整数转换为浮点数。

加

print(‘2 + 3 =’, 2 + 3) # 2 + 3 = 5

减

print(‘3 - 2 =’, 3 - 2) # 3 - 2 = 1

乘

print(‘5 * 8 =’, 5 * 8) # 5 * 8 = 40

除

得到浮点数，完整的结果

print(‘5 / 2 =’, 5 / 2) # 5 / 2 = 2.5

得到一个整数

print(‘5 // 2 =’, 5 // 2) # 5 // 2 = 2

取余

print(‘5 % 2 =’, 5 % 2) # 5 % 2 = 1

乘方

print(‘5 ** 2 =’, 5 ** 2) # 5 ** 2 = 25
复制代码

字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。一般是用单引号 '' 或者 "" 括起来。

注意，Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。并且，Python 字符串是不可变，向一个索引位置赋值，如 strs[0]='m' 会报错。

可以通过索引值或者切片来访问字符串的某个或者某段元素，注意索引值从 0 开始，例子如下所示：

切片的格式是 [start:end]，实际取值范围是 [start:end) ，即不包含 end 索引位置的元素。还会除了正序访问，还可以倒序访问，即索引值可以是负值。

具体示例如下所示：

s1 = “talk is cheap”
s2 = ‘show me the code’
print(s1)
print(s2)

索引值以 0 为开始值，-1 为从末尾的开始位置

print('输出 s1 第一个到倒数第二个的所有字符: ', s1[0:-1]) # 输出第一个到倒数第二个的所有字符
print('输出 s1 字符串第一个字符: ', s1[0]) # 输出字符串第一个字符
print('输出 s1 从第三个开始到第六个的字符: ', s1[2:6]) # 输出从第三个开始到第六个的字符
print(‘输出 s1 从第三个开始的后的所有字符:’, s1[2:]) # 输出从第三个开始的后的所有字符

加号 + 是字符串的连接符

星号 * 表示复制当前字符串，紧跟的数字为复制的次数

str = "I love python "
print(“连接字符串:”, str + “!!!”)
print(“输出字符串两次:”, str * 2)

反斜杠 \ 转义特殊字符

若不想让反斜杠发生转义，可以在字符串前面添加一个 r

print(‘I\nlove\npython’)
print(“反斜杠转义失效:”, r’I\nlove\npython’)
复制代码

注意：

• 1、反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
• 2、字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• 3、Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• 4、Python 中的字符串不能改变。

字符串包含了很多内置的函数，这里只介绍几种非常常见的函数：

• strip(x)：当包含参数 x 表示删除句首或者句末 x 的部分，否则，就是删除句首和句末的空白字符，并且可以根据需要调用 lstrip() 和 rstrip() ，分别删除句首和句末的空白字符；
• split()：同样可以包含参数，如果不包含参数就是将字符串变为单词形式，如果包含参数，就是根据参数来划分字符串；
• join()：主要是将其他类型的集合根据一定规则变为字符串，比如列表；
• replace(x, y)：采用字符串 y 代替 x
• index()：查找指定字符串的起始位置
• startswith() / endswith()：分别判断字符串是否以某个字符串为开始，或者结束；
• find()：查找某个字符串；
• upper() / lower() / title()：改变字符串的大小写的三个函数

下面是具体示例代码：

strip()

s3 = " I love python "
s4 = “show something!”
print('输出直接调用 strip() 后的字符串结果: ', s3.strip())
print('lstrip() 删除左侧空白后的字符串结果: ', s3.lstrip())
print(‘rstrip() 删除右侧空白后的字符串结果: ‘, s3.rstrip())
print(‘输出调用 strip(’!’)后的字符串结果: ‘, s4.strip(’!’))

split()

s5 = ‘hello, world’
print(‘采用split()的字符串结果: ‘, s5.split())
print(‘采用split(’,’)的字符串结果: ‘, s5.split(’,’))

join()

l1 = [‘an’, ‘apple’, ‘in’, ‘the’, ‘table’]
print('采用join()连接列表 l1 的结果: ‘, ‘’.join(l1))
print(‘采用’-’.join()连接列表 l1 的结果: ', ‘-’.join(l1))

replace()

print('replace(‘o’, ‘l’)的输出结果: ', s5.replace(‘o’, ‘l’))

index()

print('s5.index(‘o’)的输出结果: ', s5.index(‘o’))

startswith() / endswith()

print('s5.startswith(‘h’)的输出结果: ', s5.startswith(‘h’))
print('s5.endswith(‘h’)的输出结果: ', s5.endswith(‘h’))

find()

print('s5.find(‘h’)的输出结果: ', s5.find(‘h’))

upper() / lower() / title()

print('upper() 字母全大写的输出结果: ', s5.upper())
print('lower() 字母全小写的输出结果: ', s5.lower())
print('title() 单词首字母大写的输出结果: ', s5.title())
复制代码

列表

列表是 Python 中使用最频繁的数据类型，它可以完成大多数集合类的数据结构实现，可以包含不同类型的元素，包括数字、字符串，甚至列表（也就是所谓的嵌套）。

和字符串一样，可以通过索引值或者切片(截取)进行访问元素，索引也是从 0 开始，而如果是倒序，则是从 -1 开始。列表截取的示意图如下所示：

另外，还可以添加第三个参数作为步长：

同样，列表也有很多内置的方法，这里介绍一些常见的方法：

• len(list)：返回列表的长度
• append(obj) / insert(index, obj) / extend(seq)：增加元素的几个方法
• pop() / remove(obj) / del list[index] / clear()：删除元素
• reverse() / reversed：反转列表
• sort() / sorted(list)：对列表排序，注意前者会修改列表内容，后者返回一个新的列表对象，不改变原始列表
• index()：查找给定元素第一次出现的索引位置

初始化列表的代码示例如下：

创建空列表，两种方法

list1 = list()
list2 = []

初始化带有数据

list3 = [1, 2, 3]
list4 = [‘a’, 2, ‘nb’, [1, 3, 4]]

print(‘list1:’, list1)
print(‘list2:’, list2)
print(‘list3:’, list3)
print(‘list4:’, list4)
print('len(list4): ', len(list4))
复制代码

添加元素的代码示例如下：

末尾添加元素

list1.append(‘abc’)
print(‘list1:’, list1)

末尾添加另一个列表，并合并为一个列表

list1.extend(list3)
print(‘list1.extend(list3), list1:’, list1)
list1.extend((1, 3))
print(‘list1.extend((1,3)), list1:’, list1)

通过 += 添加元素

list2 += [1, 2, 3]
print(‘list2:’, list2)
list2 += list4
print(‘list2:’, list2)

在指定位置添加元素,原始位置元素右移一位

list3.insert(0, ‘a’)
print(‘list3:’, list3)

末尾位置添加，原来末尾元素依然保持在末尾

list3.insert(-1, ‘b’)
print(‘list3:’, list3)
复制代码

删除元素的代码示例如下：

del 删除指定位置元素

del list3[-1]
print(‘del list3[-1], list3:’, list3)

pop 删除元素

pop_el = list3.pop()
print(‘list3:’, list3)
print(‘pop element:’, pop_el)

pop 删除指定位置元素

pop_el2 = list3.pop(0)
print(‘list3:’, list3)
print(‘pop element:’, pop_el2)

remove 根据值删除元素

list3.remove(1)
print(‘list3:’, list3)

clear 清空列表

list3.clear()
print(‘clear list3:’, list3)
复制代码

查找元素和修改、访问元素的代码示例如下：

index 根据数值查询索引

ind = list1.index(3)
print(‘list1.index(3)，index=’, ind)

访问列表第一个元素

print('list1[0]: ', list1[0])

访问列表最后一个元素

print('list1[-1]: ', list1[-1])

访问第一个到第三个元素

print('list1[:3]: ', list1[:3])

访问第一个到第三个元素,步长为2

print('list1[:3:2]: ', list1[:3:2])

复制列表

new_list = list1[:]
print(‘copy list1, new_list:’, new_list)
复制代码

排序的代码示例如下：

list5 = [3, 1, 4, 2, 5]
print(‘list5:’, list5)

use sorted

list6 = sorted(list5)
print(‘list6=sorted(list5), list5={}, list6={}’.format(list5, list6))

use list.sort()

list5.sort()
print('list5.sort(), list5: ', list5)
复制代码

sorted() 都不会改变列表本身的顺序，只是对列表临时排序，并返回一个新的列表对象；

相反，列表本身的 sort() 会永久性改变列表本身的顺序。

另外，如果列表元素不是单纯的数值类型，如整数或者浮点数，而是字符串、列表、字典或者元组，那么还可以自定义排序规则，这也就是定义中最后两行，例子如下：

列表元素也是列表

list8 = [[4, 3], [5, 2], [1, 1]]
list9 = sorted(list8)
print(‘list9 = sorted(list8), list9=’, list9)

sorted by the second element

list10 = sorted(list8, key=lambda x: x[1])
print(‘list10 = sorted(list8, key=lambda x:x[1]), list10=’, list10)
list11 = sorted(list8, key=lambda x: (x[1], x[0]))
print(‘list11 = sorted(list8, key=lambda x:(x[1],x[0])), list11=’, list11)

列表元素是字符串

list_str = [‘abc’, ‘pat’, ‘cda’, ‘nba’]
list_str_1 = sorted(list_str)
print(‘list_str_1 = sorted(list_str), list_str_1=’, list_str_1)

根据第二个元素排列

list_str_2 = sorted(list_str, key=lambda x: x[1])
print(‘list_str_2 = sorted(list_str, key=lambda x: x[1]), list_str_2=’, list_str_2)

先根据第三个元素，再根据第一个元素排列

list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0]))
print(‘list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])), list_str_3=’, list_str_3)
复制代码

反转列表的代码示例如下：

反转列表

list5.reverse()
print('list5.reverse(), list5: ', list5)
list7 = reversed(list5)
print(‘list7=reversed(list5), list5={}, list7={}’.format(list5, list7))
#for val in list7:

print(val)

注意不能同时两次

list7_val = [val for val in list7]
print(‘采用列表推导式, list7_val=’, list7_val)
list8 = list5[::-1]
print(‘list5 = {}\nlist_reversed = list5[::-1], list_reversed = {}’.format(list5, list_reversed))
复制代码

reverse() 方法会永久改变列表本身，而 reversed() 不会改变列表对象，它返回的是一个迭代对象，如例子输出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要获取其排序后的结果，需要通过 for 循环，或者列表推导式，但需要注意，它仅仅在第一次遍历时候返回数值。

以及，一个小小的技巧，利用切片实现反转，即 <list> = <list>[::-1]。

元组

元组和列表比较相似，不同之处是元组不能修改，然后元组是写在小括号 () 里的。

元组也可以包含不同的元素类型。简单的代码示例如下：

t1 = tuple()
t2 = ()
t3 = (1, 2, ‘2’, [1, 2], 5)

创建一个元素的元祖

t4 = (7, )
t5 = (2)
print(‘创建两个空元组：t1={}, t2={}’.format(t1, t2))
print(‘包含不同元素类型的元组：t3={}’.format(t3))
print(‘包含一个元素的元祖: t4=(7, )={}, t5=(2)={}’.format(t4, t5))
print(‘type(t4)={}, type(t5)={}’.format(type(t4), type(t5)))
print(‘输出元组的第一个元素：{}’.format(t3[0]))
print(‘输出元组的第二个到第四个元素：{}’.format(t3[1:4]))
print(‘输出元祖的最后一个元素: {}’.format(t3[-1]))
print(‘输出元祖两次: {}’.format(t3 * 2))
print(‘连接元祖: {}’.format(t3 + t4))
复制代码

元祖和字符串也是类似，索引从 0 开始，-1 是末尾开始的位置，可以将字符串看作一种特殊的元组。

此外，从上述代码示例可以看到有个特殊的例子，创建一个元素的时候，必须在元素后面添加逗号，即如下所示:

tup1 = (2,) # 输出为 (2,)
tup2 = (2) # 输出是 2
print(‘type(tup1)={}’.format(type(tup1))) # 输出是 <class ‘tuple’>
print(‘type(tup2)={}’.format(type(tup2))) # 输出是 <class ‘int’>
复制代码

还可以创建一个二维元组，代码例子如下：

创建一个二维元组

tups = (1, 3, 4), (‘1’, ‘abc’)
print(‘二维元组: {}’.format(tups)) # 二维元组: ((1, 3, 4), (‘1’, ‘abc’))
复制代码

然后对于函数的返回值，如果返回多个，实际上就是返回一个元组，代码例子如下：

def print_tup():
return 1, ‘2’

res = print_tup()
print(‘type(res)={}, res={}’.format(type(res), res)) # type(res)=<class ‘tuple’>, res=(1, ‘2’)
复制代码

元组不可修改，但如果元素可修改，那可以修改该元素内容，代码例子如下所示：

tup11 = (1, [1, 3], ‘2’)
print(‘tup1={}’.format(tup11)) # tup1=(1, [1, 3], ‘2’)
tup11[1].append(‘123’)
print(‘修改tup11[1]后，tup11={}’.format(tup11)) # 修改tup11[1]后，tup11=(1, [1, 3, ‘123’], ‘2’)
复制代码

因为元组不可修改，所以仅有以下两个方法：

• count(): 计算某个元素出现的次数
• index(): 寻找某个元素第一次出现的索引位置

代码例子：

count()

print(‘tup11.count(1)={}’.format(tup11.count(1)))

index()

print(‘tup11.index(‘2’)={}’.format(tup11.index(‘2’)))
复制代码

字典

字典也是 Python 中非常常用的数据类型，具有以下特点：

• 它是一种映射类型，用 {} 标识，是无序的 键(key): 值(value) 的集合；
• 键(key) 必须使用不可变类型；
• 同一个字典中，键必须是唯一的；

创建字典的代码示例如下，总共有三种方法：

{} 形式

dic1 = {‘name’: ‘python’, ‘age’: 20}

内置方法 dict()

dic2 = dict(name=‘p’, age=3)

字典推导式

dic3 = {x: x**2 for x in {2, 4, 6}}

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注软件测试）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
format(tup11.index(‘2’)))
复制代码

字典

字典也是 Python 中非常常用的数据类型，具有以下特点：

• 它是一种映射类型，用 {} 标识，是无序的 键(key): 值(value) 的集合；
• 键(key) 必须使用不可变类型；
• 同一个字典中，键必须是唯一的；

创建字典的代码示例如下，总共有三种方法：

{} 形式

dic1 = {‘name’: ‘python’, ‘age’: 20}

内置方法 dict()

dic2 = dict(name=‘p’, age=3)

字典推导式

dic3 = {x: x**2 for x in {2, 4, 6}}

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注软件测试）
[外链图片转存中…(img-ZnPl9XuR-1713467848115)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！