python基础笔记
Posted Zbuter
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python基础笔记相关的知识，希望对你有一定的参考价值。
一、运算符
1.算术运算符
假设变量a的值是10，变量b的值是21，则 -
| 运算符 | 描述 | 示例 |
|---|---|---|
+ |
加法运算，将运算符两边的操作数增加。 | a + b = 31 |
- |
减法运算，将运算符左边的操作数减去右边的操作数。 | a – b = -11 |
* |
乘法运算，将运算符两边的操作数相乘 | a * b = 210 |
/ |
除法运算，用右操作数除左操作数 | b / a = 2.1 |
% |
模运算，用右操作数除数左操作数并返回余数 | b % a = 1 |
** |
对运算符进行指数(幂)计算 | a ** b，表示10的21次幂 |
// |
地板除 - 操作数的除法，其结果是删除小数点后的商数。 但如果其中一个操作数为负数，则结果将被保留，即从零(向负无穷大)舍去 | 9//2 = 4 ， 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0 |
2.比较(关系)运算符
比较(关系)运算符比较它们两边的值，并确定它们之间的关系。它们也称为关系运算符。假设变量a的值10，变量b的值是20，则 -
| 运算符 | 描述 | 示例 |
|---|---|---|
== |
如果两个操作数的值相等，则条件为真。 | (a == b)求值结果为 false |
!= |
如果两个操作数的值不相等，则条件为真。 | (a != b)求值结果为 true |
> |
如果左操作数的值大于右操作数的值，则条件成为真。 | (a > b)求值结果为 false |
< |
如果左操作数的值小于右操作数的值，则条件成为真。 | (a < b)求值结果为 true |
>= |
如果左操作数的值大于或等于右操作数的值，则条件成为真。 | (a >= b)求值结果为 false |
<= |
如果左操作数的值小于或等于右操作数的值，则条件成为真。 | (a <= b)求值结果为 true |
3.赋值运算符
假设变量a的值10，变量b的值是20，则 -
| 运算符 | 描述 | 示例 |
|---|---|---|
= |
将右侧操作数的值分配给左侧操作数 | c = a + b表示将a + b的值分配给c |
+= |
将右操作数相加到左操作数，并将结果分配给左操作数 | c + = a等价于c = c + a |
-= |
从左操作数中减去右操作数，并将结果分配给左操作数 | c -= a 等价于 c = c - a |
*= |
将右操作数与左操作数相乘，并将结果分配给左操作数 | c *= a 等价于 c = c * a |
/= |
将左操作数除以右操作数，并将结果分配给左操作数 | c /= a 等价于 c = c / a |
%= |
将左操作数除以右操作数的模数，并将结果分配给左操作数 | c %= a 等价于 c = c % a |
**= |
执行指数(幂)计算，并将值分配给左操作数 | c **= a 等价于 c = c ** a |
//= |
运算符执行地板除运算，并将值分配给左操作数 | c //= a 等价于 c = c // a |
4.逻辑运算符
Python语言支持以下逻辑运算符。假设变量a的值为True，变量b的值为False，那么 -
| 运算符 | 描述 | 示例 |
|---|---|---|
and |
如果两个操作数都为真，则条件成立。 | (a and b)的结果为False |
or |
如果两个操作数中的任何一个非零，则条件成为真。 | (a or b)的结果为True |
not |
用于反转操作数的逻辑状态。 | not(a and b) 的结果为True。 |
5.按位运算符
按位运算符执行逐位运算。 假设变量a = 60; 和变量b = 13; 现在以二进制格式，它们将如下 -
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Python的内置函数bin()可用于获取整数的二进制表示形式。
以下是Python语言支持位运算操作符 -
| 运算符 | 描述 | 示例 |
|---|---|---|
& |
如果它存在于两个操作数中，则操作符复制位到结果中 | (a & b) 结果表示为 0000 1100 |
| | | 如果它存在于任一操作数，则复制位。 | (a|b) = 61 结果表示为 0011 1101 |
^ |
二进制异或。如果它是一个操作数集合，但不是同时是两个操作数则将复制位。 | (a ^ b) = 49 (结果表示为 0011 0001) |
~ |
二进制补码，它是一元的，具有“翻转”的效果。 | (~a ) = -61有符号的二进制数，表示为1100 0011的补码形式。 |
<< |
二进制左移，左操作数的值由右操作数指定的位数左移。 | a << 2 = 240 (结果表示为 1111 0000) |
>> |
二进制右移，左操作数的值由右操作数指定的位数右移。 | a >> 2 = 15(结果表示为0000 1111) |
6.成员运算符
Python成员运算符测试给定值是否为序列中的成员，例如字符串，列表或元组。 有两个成员运算符，如下所述 -
| 运算符 | 描述 | 示例 |
|---|---|---|
in |
如果在指定的序列中找到一个变量的值，则返回true，否则返回false。 |
- |
not in |
如果在指定序列中找不到变量的值，则返回true，否则返回false。 |
- |
7.身份运算符
身份运算符比较两个对象的内存位置。常用的有两个身份运算符，如下所述 -
| 运算符 | 描述 | 示例 |
|---|---|---|
is |
如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。 |
|
is not |
如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。 |
- |
8. 运算符优先级
下表列出了从最高优先级到最低优先级的所有运算符，如下所示 -
| 序号 | 运算符 | 描述 |
|---|---|---|
| 1 | ** |
指数(次幂)运算 |
| 2 | ~ + - |
补码，一元加减(最后两个的方法名称是+@和-@) |
| 3 | * / % // |
乘法，除法，模数和地板除 |
| 4 | + - |
|
| 5 | >> << |
向右和向左位移 |
| 6 | & |
按位与 |
| 7 | ^| |
按位异或和常规的“OR” |
| 8 | <= < > >= |
比较运算符 |
| 9 | <> == != |
等于运算符 |
| 10 | = %= /= //= -= += *= **= |
赋值运算符 |
| 11 | is is not |
身份运算符 |
| 12 | in not in |
成员运算符 |
| 13 | not or and |
逻辑运算符 |
二、数据类型：
1、数字
int（整型）
def bit_length(self):
""" 返回表示该数字的时占用的最少位数 """
"""
int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
\'0b100101\'
>>> (37).bit_length()
6
"""
return 0
def __int__(self):
""" 转换为整数 """
""" x.__int__() <==> int(x) """
pass
#等价于 int(x)
2、字符串：str
字符串一旦创建之后就不能修改，若修改就会重新创建一个新的字符串。
（1）字符串常用方法：
1、upper(self) ---->将字符串中所有字母大写，不去管其它非字母字符。
参数：无
返回值：字符串
str1 = \'hello my name is 张\' print(str1.upper())
输出：
HELLO MY NAME IS 张
2、lower(self) ---->把全部字母字符转换成小写，不去管其它非字母字符。
参数：无
返回值：字符串
str1 = \'Zbuter\' print(str1.lower())
输出：
zbuter
3、swapcase(self) ---->将字符串中的大小写字符互换
参数：无
返回值：字符串
str1 = \'张Zbuter\' print(str1.swapcase())
输出：
张zBUTER
4、count(self, sub, start=None, end=None) ---->计算字符串中从 start 开始到 end 结束 sub 出现的次数 start 默认是字符串开始 end 默认是字符串结束
参数：
sub：字符或字符串
start：开始的索引位置
end：结束的索引位置
返回值：字符串中sub出现的次数
hello = \'hello world\' print(hello.count(\'o\')) print(hello.count(\'o\',6))
输出：
2 1
5、capitalize(self) ---->将字符串的首字母大写
参数：无
返回值：将字符串的首字母大写的字符串
name = \'zjs\' print(name.capitalize())
输出：
Zjs
6、casefold(self) 与 lower(self) ---->将字符串小写
参数：无
返回值：将字符串小写的字符串
name = \'ZJS\' print(name.lower()) print(name.casefold())
输出：
zjs zjs
casefold(self) 与 lower(self)的区别是：
lower() 只对 ASCII 也就是 \'A-Z\'有效，但是其它一些语言里面存在小写的情况就没办法了。文档里面举得例子是德语中\'ß\'的小写是\'ss\'（这个我也不懂）
7、center(self, width, fillchar=None) ---->将字符串居中用fillchar填充 一共width个字符 默认是使用空格填充 返回新的字符串
参数：
width：新形成的字符串长度，如果源字符串比width指定的长度长则直接返回源字符串
fillchar：指定一个字符来填充
返回值：填充后的字符串
name = \'ZJS\' print(name.center(20)) print(name.center(20, \'-\'))
输出：
ZJS --------ZJS---------
8、ljust(self, width, fillchar=None) ---->返回一个长度为width，左对齐的字符串，最右边填充fillchar，默认为空格。width要大于len(str)，否则返回原字符串。
str1 = \'Zbuter\' print(str1.ljust(20)) print(str1.ljust(20, \'-\'))
输出：
Zbuter Zbuter--------------
9、rjust(self, width, fillchar=None) ---->与ljust类似 右对齐
10、lstrip(self, chars=None) ---->返回一个去除前导字符的新字符串，chars参数是一个字符串，它包含了所有将要被移除的字符集合。默认为空格。
参数：
chars：字符集合
返回值：字符串
str1 = \' www.zbuter.cn\' str2 = \'www.zbuter.cn\' print(str1.lstrip()) print(str2.lstrip(\'cnw.\'))
输出：
www.zbuter.cn zbuter.cn
11、rstrip(self, chars=None) ---->与lsplit类似 从右侧开始
12、strip(self, chars=None) ---->与lstrip和rstrip类似 在字符串两头开始匹配。多用于清除字符串两端的空格
13、endswith(self, suffix, start=None, end=None) ---->判断字符串是否以 suffix 结尾 start 默认是字符串开始 end 默认是字符串结束
参数：
suffix：后缀
start：开始的索引位置
end：结束的索引位置
返回值：布尔值
hello = \'hello world\' print(hello.endswith(\'ld\')) print(hello.endswith(\'asd\'))
输出：
True False
14、startswith(self, prefix, start=None, end=None) ---->与endswith类似 判断是否以prefix开头
15、expandtabs(self, tabsize=8) ---->把字符串中的 tab 符号(\'\\t\')转为空格，tab 符号默认的空格数是 8。从头开始数，数到第一个\\t正好为8个空格，不足则补空格，如果还有\\t，接着从第一个\\t数到第二个\\t仍然为8个空格，以此类推直到最后一个\\t结束。
参数：
tabsize：指定转换字符串中的 tab 符号(\'\\t\')转为空格的字符数，默认的字符数是8。
返回值：该方法返回字符串中的 tab 符号(\'\\t\')转为空格后生成的新字符串。
hello = \'hello\\tworld\' print(hello.expandtabs(4)) print(hello.expandtabs(10))
输出：
hello world hello world
16、find(self, sub, start=None, end=None) ---->在字符串中查找 sub 出现的位置
参数：
sub：指定查找的字符串或字符
start：开始的索引位置
end：结束的索引位置
返回值：sub出现的第一次的索引 如果不存在则返回-1
hello = \'hello\\tworld\' print(hello.find(\'o\')) print(hello.find(\'z\'))
输出：
4 -1
17、rfind(self, sub, start=None, end=None) ---->与find类似 从右侧查找
18、index(self, sub, start=None, end=None) ---->在字符串中查找 sub 出现的位置
参数：
sub：指定查找的字符串或字符
start：开始的索引位置
end：结束的索引位置
返回值：sub出现的第一次的索引 如果不存在则抛出异常
hello = \'hello\\tworld\' print(hello.index(\'o\')) print(hello.index(\'z\'))
输出：
4
Traceback (most recent call last):
File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 36, in <module>
print(hello.index(\'z\'))
ValueError: substring not found
19、rindex(self, sub, start=None, end=None) ---->与index类似 从右侧查找
20、title(self) ---->将字符串中所有单词的首字母大写
参数：无
返回值：字符串
str1 = \'hello my name is 张\' print(str1.title())
输出：
Hello My Name Is 张
21、replace(self, old, new, count=None) ---->用 new 替换原字符串中的 old ，count指定替换的次数
参数：
old：需要替换的字符（串）
new：替换的字符（串）
count：替换的次数不超过count次
返回值：字符串
str1 = \'www.zbuter.cn\' str2 = \'www.zbuter.cn\' print(str1.replace(\'.\', \'。\')) print(str2.replace(\'.\', \'，\', 1))
输出：
www。zbuter。cn www，zbuter.cn
22、partition(self, sep) ---->该方法用于拆分字符串，返回一个包含三个元素的元组。如果未能在原字符串中找到Sep，则元组的三个元素为：原字符串，空串，空串；否则，从原字符串中遇到的第一个Sep字符开始拆分，元组的三个元素为：Sep之前的字符串，Sep字符，Sep之后的字符串；
参数：
sep：分割标记
返回值：元祖
str1 = \' www.zbuter.cn\' str2 = \'www.zbuter.cn\' print(str1.partition(\'.\')) print(str2.partition(\'z\'))
输出：
(\' www\', \'.\', \'zbuter.cn\') (\'www.\', \'z\', \'buter.cn\')
23、rpartition(self, sep) ---->与partition类似 从右侧查找sep
24、split(self, sep=None, maxsplit=-1) ---->返回一个以Sep分隔的列表，maxsplit指定拆分次数（因此，列表中元素的个数为maxsplit + 1）。Sep默认为空格，maxsplit默认不限制拆分次数。
参数：
sep：分隔符
maxsplit：拆分次数
返回值：字符串
str1 = \'www.zbuter.cn\' str2 = \'www.zbuter.cn\' print(str1.split(\'.\')) print(str2.split(\'.\', 1))
输出：
[\'www\', \'zbuter\', \'cn\'] [\'www\', \'zbuter.cn\']
25、rsplit(self, sep=None, maxsplit=-1) ---->与 split 类似 从右侧拆分
26、splitlines(self, keepends=None) ---->拆分一个包含多行的字符串，以每行为一个元素返回一个列表 keepends是一个True字符或非零整数
参数：
keepends：是否在列表内也添加换行符
返回值：字符串
str1 = \'123\\n456\' str2 = \'123\\n456\' print(str1.splitlines()) print(str2.splitlines(True))
输出：
[\'123\', \'456\'] [\'123\\n\', \'456\']
27、join(self, iterable) ---->使用连接符str来连接iterable对象中的元素，如果传入一个非iterable对象，如整数、布尔值等，将抛出异常Type Error。
参数：iterable：使用字符串来连接iterable
返回值：字符串
str1 = \'Zbuter\' print(str1.join(\'12\')) print(str1.join(\'123\')) print(str1.join(123))
输出：
1Zbuter2
1Zbuter2Zbuter3
Traceback (most recent call last):
File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 39, in <module>
print(str1.join(123))
TypeError: can only join an iterable
28、zfill(self, width) ---->返回一个长度为width的数字字符串，最左边填充0。如果width小于等于原字符串长度，则返回原字符串。主要用于数字类字符串的格式化。
参数：
width：填充的宽度
返回值：字符串
str1 = \'aaa\' str2 = \'123\' print(str1.zfill(5)) print(str2.zfill(5))
输出：
00aaa 00123
29、format(self, *args, **kwargs) ---->格式化字符串
参数：
*args：是用来发送一个（非键值对）可变数量的参数列表给一个函数
**kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数。 如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs。
返回值：格式化后的新字符串
str1 = \'my name is {name} age is {age}\'
str2 = \'my name is {0} age is {1}\'
print(str1.format(name = \'zjs\', age = 12))
print(str2.format(\'zjs\', 12))
输出：
my name is zjs age is 12 my name is zjs age is 12
更多参考：http://www.cnblogs.com/wupeiqi/articles/5484747.html
30、format_map(self, mapping) ----> 待更新
31、isalnum(self) ---->字符串中是否只含数字、字母
参数：无
返回值：布尔值
str1 = \'123abc\' str2 = \'123_abc\' print(str1.isalnum()) print(str2.isalnum())
输出：
True False
32、isalpha(self) ---->字符串是否只含有字母
参数：无
返回值：布尔值
str1 = \'abcdef\' str2 = \'_abc\' print(str1.isalpha()) print(str2.isalpha())
输出：
True False
33、isdecimal(self) ---->字符串是否只包含十进制字符。这种方法只存在于unicode对象。
参数：无
返回值：布尔值
str1 = \'123\' str2 = \'this123\' print(str1.isdecimal()) print(str2.isdecimal())
输出：
True False
34、isdigit(self) ---->检测字符串是否只由数字组成。
参数：无
返回值：布尔值
str1 = \'123\' str2 = \'this123\' print(str1.isdigit()) print(str2.isdigit())
输出：
True False
35、isidentifier(self) ---->判断字符串是否是合法的标识符
参数：无
返回值：布尔值
str1 = \'_a\' str2 = \'1a\' print(str1.isidentifier()) print(str2.isidentifier())
输出：
True False
36、islower(self) ---->判断字符串是否全是小写
参数：无
返回值：布尔值
str1 = \'abcdefg\' str2 = \'Abcdefg\' print(str1.islower()) print(str2.islower())
输出：
True False
37、isnumeric(self) ---->判断字符串是否只包含数字字符。数字字符范围很大，一般来说，数字字符是拥有如下属性值的字符：Numeric_Type=Digit, Numeric_Type=Decimal或Numeric_Type=Numeric。比较isdecimal()、isdigit()、isnumeric()，几个方法检测的范围依次扩大。
参数：无
返回值：布尔值
str1 = \'123\' str2 = \'a123\' print(str1.isnumeric()) print(str2.isnumeric())
输出：
True False
38、isprintable(self) ---->判断字符串所包含的字符是否全部可打印
参数：无
返回值：布尔值
str1 = \'hello world\' str2 = \'hello\\tworld\' print(str1.isprintable()) print(str2.isprintable())
输出：
True False
39、isspace(self) ---->判断字符串是否仅包含空格或制表符
参数：无
返回值：布尔值
str1 = \' \\t \\n\' str2 = \'\' print(str1.isspace()) print(str2.isspace())
输出：
True False
40、istitle(self) ---->判断字符串每个单词的首字母是否大写
参数：无
返回值：布尔值
str1 = \'张家顺\' str2 = \'Zbuter\' str3 = \'张家顺Zbuter\' print(str1.istitle()) print(str2.istitle()) print(str3.istitle())
输出：
False True True
41、isupper(self) ---->与islower()相反 判断字符串是否全部大写
42、encode(self, encoding=\'utf-8\', errors=\'strict\') ---->
43、decode(self, *args, **kwargs) ---->
44、maketrans(self, *args, **kwargs)
45、translate(self, table)
maketrans 与 translate 配合使用
str = \'30416657\' trans = str.maketrans(\'0123456789\', \'零一二三四五六七八九\') print(str.translate(trans))
输出：
三零四一六六五七
（2）字符串的索引：
str = \'zbuter\' print(str[0], str[1]) print(str[-1], str[-2]) # 负号代表在字符串后面数
输出：
z b r e
str[0]代表字符串的第一个字符 以此类推
用于获取字符串中某一个字符
（3）字符串的切片：
str = \'zbuter\' print(str[0:2]) print(str[:2]) # 与 str[0:2] 含义相同 print(str[:-1]) # 表示从 0 到 最后一个字符（不含） print(str[2:-1]) #从第二个字符到最后一个字符）（不含）
输出：
zb zb zbute ute
（4）字符串的长度
str = \'zbuter\' print(len(str))
输出：
6
（5）字符串内字符的遍历
str1 = "hello my name is zjs"
for s in str1:
print(s)
输出：
h
e
l
l
o
m
y
n
a
m
e
i
s
z
j
s
3、列表：list
创建列表：
name_list = [\'zhang\', \'wang\', \'li\'] 或 name_list ＝ list([\'zhang\', \'wang\', \'li\'])
列表内的元素是有序的
（1）常用方法：
1.append(self, p_object) ---->在列表最后追加一个元素
参数：p_object 追加的元素
返回值：None
ls = [1, \'2\', \'abc\'] s = ls.append(5) print(ls) print(s)
输出：
[1, \'2\', \'abc\', 5] None
列表可以追加任意的数据类型。包括列表、元祖和字典。
2.clear(self) ---->清空字典
参数：无
返回值：None
ls = [1, \'2\', \'abc\'] s = ls.clear() print(ls) print(s)
输出：
[]
None
3.copy(self) ---->字典的浅拷贝 只拷贝直接子对象
参数：无
返回值：列表
ls = [1, \'2\', \'abc\'] s = ls.copy() print(ls) print(s) ls = [] print(ls) print(s)
输出：
[1, \'2\', \'abc\'] [1, \'2\', \'abc\'] [] [1, \'2\', \'abc\']
4.count(self, value) ---->计算value在列表中出现的次数
参数：value 可以是任意类型
返回值：int类型的数字
ls = [1, \'2\', \'abc\', 1, 1, 1] s = ls.count(1) print(ls) print(s)
输出：
[1, \'2\', \'abc\', 1, 1, 1] 4
5.insert(self, index, p_object) ---->在 index 处插入p_object
参数：
index： 索引位置
p_object：需要插入的元素
返回值：int类型的数字
ls = [1, \'2\', \'abc\'] s = ls.insert(1, 4) print(ls) print(s) ls.insert(4, 4) #插入如果超出了列表的索引范围则在最后一个位置插入 print(ls)
输出：
[1, 4, \'2\', \'abc\'] None [1, 4, \'2\', \'abc\', 4]
6.index(self, value, start=None, stop=None) ---->查找value从start开始到stop处出现的索引位置 如果不存在这个值会抛出异常
参数：
value： 需要查找的元素
start： 开始查找的索引位置 默认是列表的第一个元素
stop： 结束查找的索引位置 默认是列表的最后一个元素
返回值：int类型数字 value第一次出现的索引位置
ls = [0, \'2\', \'abc\', 1, 1, 1] s = ls.index(1, 2, 4) print(s) s = ls.index(1, 2, 3) print(s)
输出：
3 Traceback (most recent call last): File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 69, in <module> s = ls.index(1, 2, 3) ValueError: 1 is not in list
7.extend(self, iterable) ---->在列表后追加一个可迭代的值
参数：iterable 追加的可迭代元素
返回值：None
ls = [0, \'2\', \'abc\', 1, 1, 1] ex = [\'a\', \'bc\', 1, 3] s = ls.extend(ex) print(ls) print(s)
输出：
[0, \'2\', \'abc\', 1, 1, 1, \'a\', \'bc\', 1, 3] None
与append不同，
append一个列表是把列表整体追加到列表尾部，
extend则是一个一个追加到列表的末尾，
extend不接受数字类型，只能传递一个可迭代对象
8.pop(self, index=None) ---->删除列表中最后一个元素。若index指定则删除index处的元素
参数：index 删除的元素索引
返回值：None
ls = [0, \'2\', \'abc\', 1, 1, 1] ex = [\'a\', \'bc\', 1, 3] s = ls.pop() print(ls) print(s) s = ls.pop(2) print(ls) print(s)
输出：
[0, \'2\', \'abc\', 1, 1] 1 [0, \'2\', 1, 1] abc
9.remove(self, value) ---->从列表中删除第一个value匹配值
参数：value 需要删除的元素
返回值：None
ls = [0, \'2\', \'abc\', 1, 1, 1] s = ls.remove(1) print(ls) print(s)
输出：
[0, \'2\', \'abc\', 1, 1] None
10.reverse(self) ---->将列表逆置
参数：None
返回值：None
ls = [0, \'2\', \'abc\', 1, 1, 1] s = ls.reverse() print(ls) print(s)
输出：
[1, 1, 1, \'abc\', \'2\', 0] None
11.sort(self, key=None, reverse=False) ---->对列表进行排序 若reverse指定为True则为从大到小排序
参数：
key：待更新
reverse：排序方式 默认为升序排列
返回值：None
ls = [4, 1, 3, 6, 7, 2] s = ls.sort() print(ls) print(s) s = ls.sort(reverse=True) print(ls) print(s)
输出：
[1, 2, 3, 4, 6, 7] None [7, 6, 4, 3, 2, 1] None
（2）访问列表中的值：
使用索引的方式访问列表：
ls = [\'baidu\', \'souhu\', 1995, 2018];
print("ls[0]: ", ls[0])
print("ls[1:5]: ", ls[1:5])
输出：
ls[0]: baidu ls[1:5]: [\'souhu\', 1995, 2018]
获得列表中第一个值和最后一个值。
ls = [\'baidu\', \'souhu\', 1995, 2018]; name, *_, year = ls # *（星）代表name和year中间的所有元素的之赋值给 _（下划线）。 print(name) print(_) print(year)
输出：
baidu [\'souhu\', 1995] 2018
（3）列表的更新：
ls = [\'baidu\', \'souhu\', 1995, 2018];
print("ls[3]: ", ls[3])
ls[3] = 1111
print("更新后的ls[3]: ", ls[3])
输出：
ls = [\'baidu\', \'souhu\', 1995, 2018]; print("ls[3]: ", ls[3]) ls[3] = 1111 print("更新后的ls[3]: ", ls[3])
（4）列表元素的删除：
ls = [\'baidu\', \'souhu\', 1995, 2018, \'test\', \'hello\', [1,2,3]] del ls[2] print(ls) ls.remove(2018) print(ls) ls.pop() print(ls) ls.clear() #无论列表中有多少元素都全部删除 print(ls)
输出：
[\'baidu\', \'souhu\', 2018, \'test\', \'hello\', [1, 2, 3]] [\'baidu\', \'souhu\', \'test\', \'hello\', [1, 2, 3]] [\'baidu\', \'souhu\', \'test\', \'hello\'] []
（5）列表的操作符：
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| [\'Hi!\'] * 4 | [\'Hi!\', \'Hi!\', \'Hi!\', \'Hi!\'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
（5）列表的遍历：
list1 = [\'abc\', 123, (1, 2), [22, 33, 44, "ttt"]]
for item in list1:
print(item)
输出：
abc 123 (1, 2) [22, 33, 44, \'ttt\']
4、元祖：tuple
元祖的创建方法：
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
元祖的元素是有序的。
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
（1）元祖常用方法：
1.count(self, value) ---->与列表中count函数相同
2.index(self, value, start=None, stop=None) ---->与列表中index函数相同
（2）元祖的访问：
tuple1 = (\'baidu\', \'souhu\', 1995, 2018, \'test\', \'hello\', [1,2,3]) print(tuple1[1]) print(tuple1[2:4])
输出：
souhu
(1995, 2018)
获得元祖中第一个值和最后一个值。
ls =(\'baidu\', \'souhu\', 1995, 2018) name, *_, year = ls # *（星）代表name和year中间的所有元素的之赋值给 _（下划线）。 print(name) print(_) # 如果是元祖取出来的会是列表 print(year)
输出：
baidu
[\'souhu\', 1995]
2018
（3）元祖的修改和删除：
元祖的直接子元素不能被修改和删除，但间接子元素可以被修改或删除
元祖只能被整体删除。
tuple1 = (\'baidu\', \'souhu\', 1995, 2018, \'test\', \'hello\', [1,2,3]) tuple1[6][1] = 666 print(tuple1)
输出：
(\'baidu\', \'souhu\', 1995, 2018, \'test\', \'hello\', [1, 666, 3])
（4）元祖的运算符：
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 计算元素个数 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
| (\'Hi!\',) * 4 | (\'Hi!\', \'Hi!\', \'Hi!\', \'Hi!\') | 复制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print (x,) | 1 2 3 | 迭代 |
（5）元祖的遍历：
tuple1 = (\'abc\', 123, (1, 2), [22, 33, 44, "ttt"])
for item in tuple1:
print(item)
输出：
abc 123 (1, 2) [22, 33, 44, \'ttt\']
5、字典：dict
字典的创建：
person = {"name": "zjs", \'age\': 12}
或
person = dict({"name": "zjs", \'age\': 12})
字典中的元素是无序的
（1）字典的常用方法：
1.clear(self) ---->清空字典内所有键值对与列表相同
参数：无
返回值：无
>>> aDict = {\'name\': \'zjs\', \'age\':12, \'sex\':\'male\'}
>>> aDict.clear()
>>> print(aDict)
{}
2.copy(self) ---->对字典的浅拷贝与列表相同
参数：无
返回值：字典
>>> aDict = {\'name\': \'zjs\', \'age\':12, \'sex\':\'male\'}
>>> bDict = aDict.copy()
>>> print(aDict,bDict)
{\'sex\': \'male\', \'age\': 12, \'name\': \'zjs\'} {\'sex\': \'male\', \'age\': 12, \'name\': \'zjs\'}
3.keys(self) ---->以列表方式返回字典的所有键
参数：无
返回值：dict_keys
>>> aDict = {\'name\': \'zjs\', \'age\':12, \'sex\':\'male\'}
>>> print(aDict.keys())
dict_keys([\'sex\', \'age\', \'name\'])
4.values(self) ---->与keys类似，返回字典的所有值
参数：无
返回值：dict_values
>>> aDict = {\'name\': \'zjs\', \'age\':12, \'sex\':\'male\'}
>>> print(aDict.values())
dict_values([\'male\', 12, \'zjs\'])
5.items(self) ---->以列表的方式返回字典的键值对 每个键值对用元祖表示
参数：无
返回值：dict_items
>>> aDict = {\'name\': \'zjs\', \'age\':12, \'sex\':\'male\'}
>>> print(aDict.items())
dict_items([(\'sex\', \'male\'), (\'age\', 12), (\'name\', \'zjs\')])
6.get(self, k, d=None) ---->获得字典指定键的值
参数：
k：指定的键
d：如果指定键的值不存在时，返回该默认值值。
返回值：无
aDict = {\'name\': \'zjs\', \'age\': 12, \'sex\': \'male\'}
name = aDict.get(\'name\')
grade = aDict.get(\'grade\', 3)
print(name,grade)
输出：
zjs 3
7.update(self, E=None, **F) ---->添加指定字典到该字典内如果字典内有该键则更新这个值
参数：
E：传
以上是关于python基础笔记的主要内容，如果未能解决你的问题，请参考以下文章