python基础知识(一）

最新推荐文章于 2024-10-02 10:53:34 发布

凡我喵族，喵喵喵喵

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量132

点赞数

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

本文链接：https://blog.csdn.net/weixin_64604651/article/details/133561355

版权

python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.数字

python中的整数用int表示，相比于其他语言不区分长整形、整形，不管你输入多大的数字它都不会溢出。

python中的浮点数用float表示，不区分单精度和双精度。

2.四则运算

浮点数+浮点数=浮点数

浮点数+整数=浮点数

整数+整数=整数

整数/整数=浮点数

>>>4/2
2.0

整除操作：//

余数操作：%

字符串：

“+”可用于字符串拼接：仅限于同种类型，如果字符串和数字相加会报错。

字符串还可以乘：

>>>a="python"
>>>a*3
pythonpythonpython

转义字符：

\n:换行

\t:制表

原始字符串：表示当前不是换行字符，就是在字符串面前加r

>>>print(r'c:\now')
c:\now

索引和切片：

切片的作用区间是左闭右开的,a[2,6]相当于[2,6)

>>>a='i love python'
>>>b=a[2:6]
>>>a
'love'

字符串的切片不会影响原字符串

字符串的格式化输出：

字符的格式化就是我们定义一个模板，然后在模板的一处或几处留一些空位，以便将来在空格填上相应的字符串，溜出来的空位我们称为占位符。现在用的更多的方法是format()

>>>'i love {0} and {1}'.format('python','java')
i love python and java

常用的字符串方法：

replace（）：

split()

count()

列表：

列表的切片和索引

python中的列表用[]表示，在方括号里可以是字符串，数字或是多种不同的对象，除此之外，列表的元素可以无限大（但是要考虑硬件设备

>>>a=[1,2,'aa',[1,22]]
>>>a
[1, 2, 'aa', [1, 22]]

列表和字符串一样都有序列，列表里的元素也有序，所以列表也有索引和切片，也是左闭右开

    a=[1,2,'aa',[1,22]]
    print(a[0])
    print(a[0:2])
    print(a[3][1])#注意这里是二维数组的写法
    print(a[3:1])#

1
[1, 2]
22
[]

注意序列都是从左到右排列的，当然序列里还可以跳步，完整写法是[start:end:step]默认情况下step=1,step为负数表示从相反的方向

    a=[1,2,'aa',[1,22]]
    print(a[::2])
    print(a[::-2])

[1, 'aa']
[[1, 22], 2]

列表操作

列表的基本操作和字符串差不多，只在此说一下列表的独特操作。

列表和字符串的一个很大不同是：字符串不可修改，但是列表可以修改

    a=[1,2,'aa',[1,22]]
    a[1]='womeik'
    print(a)
    b='Monkey'
    b[0]='python'
    print(b)

[1, 'womeik', 'aa', [1, 22]]
Traceback (most recent call last):
  File "D:/python/pythonLearningDemo/main.py", line 6, in <module>
    b[0]='python'
TypeError: 'str' object does not support item assignment

除了可以修改元素以外，列表还可以给自己添加元素，使用append()方法像列表中追加元素，追加到末尾

    a=[1,2,'aa',[1,22]]
    a.append('womeik')
    print(a)

[1, 2, 'aa', [1, 22], 'womeik']

常用列表函数：

append（）：将元素追加到列表的最右边

extend（）：合并两个列表

    a=[1,2,'aa',[1,22]]
    b=['kl','jdj']
    a.extend(b)
    b.extend(a)
    print(a)
    print(b)

[1, 2, 'aa', [1, 22], 'kl', 'jdj']
['kl', 'jdj', 1, 2, 'aa', [1, 22], 'kl', 'jdj']

count（）：统计元素出现次数

    a=[1,2,'aa',[1,22],1]
    print(a.count(1))
    print(a.count(2))
    print(a.count(3))


2
1
0

index():元素第一次出现的位置

    a=[1,2,'aa',[1,22],1]
    print(a.index(2))
    print(a.index(3))

Traceback (most recent call last):
  File "D:/python/pythonLearningDemo/main.py", line 4, in <module>
    print(a.index(3))
ValueError: 3 is not in list
1

insert():在任意位置添加元素

    a=[1,2,'aa',[1,22],1]
    a.insert(1,8)
    print(a)
    a.insert(0,'white')
    print(a)


[1, 8, 2, 'aa', [1, 22], 1]
['white', 1, 8, 2, 'aa', [1, 22], 1]

remove():删除元素，元素必须在列表中并且是在原列表上删除，有重复元素时，只删除第一个

    a=[1,2,'aa',[1,22],1]
    a.remove(1)
    print(a)
    a.remove(4)

[2, 'aa', [1, 22], 1]
Traceback (most recent call last):
  File "D:/python/pythonLearningDemo/main.py", line 5, in <module>
    a.remove(4)
ValueError: list.remove(x): x not in list

pop():函数填写删除元素的索引时就是删除该元素，没有指定索引时删除列表最后一个元素，pop()有返回值就是删除的元素

a=[1,2,'aa',[1,22],1]
pop1=a.pop(1)
print(pop1)
print(a)
pop2 = a.pop()
print(pop2)
print(a)#也会修改原数组哦

运行结果：
2
[1, 'aa', [1, 22], 1]
1
[1, 'aa', [1, 22]]

reverse():在原列表上操作，将列表的元素顺序反过来

    a=[1,2,'aa',[1,22],1]
    b=a.reverse()
    print(a)
    print(b)


[1, [1, 22], 'aa', 2, 1]
None

sort():对列表进行排序，默认是递增排序，在原列表上操作

    b=['a','r','p','d','b']
    b.sort()
    print(b)

['a', 'b', 'd', 'p', 'r']

比较列表与字符串：

相同点：两者都是序列类型，可以使用切片或索引得到一个或多个元素；对于序列的基本操作，比如连接操作，len()这一类的函数也实用。

不同点：

1.列表是可变的，字符串是不可变的，append(),insert(),pop()等函数对于字符串来说都不适用。

2.列表的包容：字符串中的每一个元素都是字符，列表中的元素可以是任意一种或多种类型的组合。

元组：

定义：

元组是Python中的一个内置的数据结构，它是一个不可变的序列，所谓的不可变序列就是不可以进行增删改的操作。

    a='abc'
    print(type(a))
    b=1,'as',99,'k'
    print(type(b))

<class 'str'>
<class 'tuple'>

b的输入不会报错是因为把数据放到了一个圆括号中，这个带括号的对象就是：元组

元组用括号括起来，元组也是序列，但是元组中的元素不能够更改，和字符串类似；元组中的元素又可以是任意对象，与列表类似；

索引和切片：

元组与列表字符串相似，每个元素有自己的索引，并且可以切片

    b=1,'as',99,'k',[2,'python',99]
    print(b[1])
    print(b[::-1])
    print(b[2:3])
    print(b[4][1])

as
([2, 'python', 99], 'k', 99, 'as', 1)
(99,)
python

元组与列表相互转换：

由于元组是不可修改的，关于修改列表的方法在这里都无效，使用dir（tuple)查看元组类型有哪些方法

    print(dir(tuple))

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

虽然元组不可修改，但是元组和列表是可以相互转换的，使用list()和tuple()实现

    b=1,'as',99,'k',[2,'python',99]
    print(type(b))
    b=list(b)
    print(type(b))
    b=tuple(b)
    print(type(b))

<class 'tuple'>
<class 'list'>
<class 'tuple'>

还有一点值得提醒的就是，当元组中只有一个元素时，注意在元素后面跟上英文的逗号

    c=1
    print(type(c))
    d=1,
    print(type(d))
    e=('a')
    print(type(e))
    f=('a',)
    print(type(f))

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

元组的应用场景：

之后补充

字典：

字典也称为键值对，形式为’key':'value'，键与值之间用英文的冒号隔开。每一对键值之间使用英文的逗号隔开，在字典中，键是唯一的，不能重复，而值对应于键，可以重复

创建字典：

1.第一种方法：创建一个空的字典，然后向里面加东西（当然也可以是非空的）

    dict={}
    print(dict)
    print(type(dict))
    dict['name']='liming'
    print(dict)

{}
<class 'dict'>
{'name': 'liming'}

我们来验证一下字典是不是可修改的

    dict={}
    dict['name']='liming'
    dict["lan"]="python"
    dict["age"]="20"
    print(dict)
    dict["age"]=188
    print(dict)

{'name': 'liming', 'lan': 'python', 'age': '20'}
{'name': 'liming', 'lan': 'python', 'age': 188}

以上表明，字典是可变的

2.第二种方法，使用元组创建字典

    tuple=(['name','liming'],['age','18'])
    dict=dict(tuple)
    print(dict)
    print(type(dict))

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

强调一点：字典中的键必须是不可变的数据类型，值可以是任意数据类型，所以元组可以当字典的键，但是列表不可以，列表只能做值

    tuple=(['name','liming'],['age','18'])
    list=[1,2]
    dict=dict(tuple)
    dict['age']=19
    print(dict)
    dict[list]="lakldj"
    print(dict)
    print(type(dict))


Traceback (most recent call last):
  File "D:/python/pythonLearningDemo/main.py", line 7, in <module>
    dict[list]="lakldj"
TypeError: unhashable type: 'list'
{'name': 'liming', 'age': 19}


#在Python中,这个错误通常是由于你试图将一个可变类型的对象,
#如列表(list)放入集合(set)或作为字典(dict)的键时产生的。
#集合和字典中的元素需要是可哈希的(hashable),也就是不能够被改变的。
#列表是可变类型,其内容可以被改变,所以它是不可哈希的。
#当你遇到类似这样的错误:如果要作为字典的键,可以将列表转换为不可变的元组

字典是一种映射关系，只要知道了键就可以知道值，添加完的值并不按照它的添加顺序显示，所以在字典中既没有索引也没有切片。

字典的键值对存储数据是一种高效的查找数据方式，如果在列表中查找值，需要从头开始一个一个的寻找，直到找到值，在字典中可以通过键找到值，在数据规模比较大时，这种好处比较明显

字典的基本操作：

1.clear()

清除字典中所有元素，得到一个空的字典

    dict={'name':'liming'}
    dict.clear()
    print(dict)

{}

del是将字典删除

2.get&&setdefault

这是两个跟键值对相关的方法，get方法得到字典中某个键的值，get相比于直接按照键来查询要宽松一些，如果想查的值不存在，get不会有反应，

    dict={'name':'liming'}
    print(dict.get('age'))

None

直接按照键查询会报错

    dict={'name':'liming'}
    # print(dict.get('age'))
    print(dict)
    print(dict['age'])
    print(dict)


{'name': 'liming'}
Traceback (most recent call last):
  File "D:/python/pythonLearningDemo/main.py", line 5, in <module>
    print(dict['age'])
KeyError: 'age'

setdefault也是查找字典中某个键的值，如果键存在的话就正常输出，如果不存在就在字典中加入这个键值对

    dict={'name':'liming'}
    print(dict.setdefault("name"))
    dict.setdefault("age",23)
    print(dict)

liming
{'name': 'liming', 'age': 23}

3.items&&keys&&values

z请看实例：

    dict={'name':'liming','age':19}
    my_i=dict.items()
    print(my_i)
    my_k=dict.keys()
    print(my_k)
    my_v=dict.values()
    print(my_v)


dict_items([('name', 'liming'), ('age', 19)])
dict_keys(['name', 'age'])
dict_values(['liming', 19])

4.pop&&popitem

字典中的删除操作

pop以字典中的键为参数，删除指定的键值对，pop中的参数不能省略，如果删除字典中没有的键值会报错。

    dict={'name':'liming','age':19}
    dict.pop('name')
    print(dict)
    dict.pop("na")


{'age': 19}
Traceback (most recent call last):
  File "D:/python/pythonLearningDemo/main.py", line 5, in <module>
    dict.pop("na")
KeyError: 'na'

popitem不用写参数，但是他删除的不是最后一个，因为我们说过字典没有顺序，所以他是随机删除一个

    dict={'name':'liming','age':19,'score':78,'class':'A'}
    dict.popitem()
    print(dict)
    dict.popitem()
    print(dict)

{'name': 'liming', 'age': 19, 'score': 78}
{'name': 'liming', 'age': 19}

（1）返回并删除字典中的最后一对键和值。（Python3.7 之后的版本）
（2）返回并删除字典中的任意一对键和值。（Python3.7 之前的版本）

5.update

就是更新字典，参数是字典或者某种可迭代的对象，没有返回值

    dict={'name':'liming','age':19,'score':78,'class':'A'}
    my_dict={"teacher":"Luku"}
    dict.update(my_dict)
    print(dict)


{'name': 'liming', 'age': 19, 'score': 78, 'class': 'A', 'teacher': 'Luku'}

集合set：

集合的特点是无次序，不可重复，有的可变，有的不可变。之前我们说元组是列表和字符串部分特征的并集，那么集合我们可以看作是列表和字典部分特征的并集

创建集合

的方法，我们推荐set(),------也可以使用{}，但是为了避免歧义不建议使用）

    my_set=set("wahaha")
    print(type(my_set))
    print(my_set)
    my_set2=set(["java",'python','C','Go','java'])
    print(my_set2)


<class 'set'>
{'w', 'h', 'a'}
{'C', 'Go', 'java', 'python'}

从上面的例子可以看出，集合输出的是无序，去重的元素，这是一种高效的去重方式

集合的方法：

使用dir(set)查看相关方法

['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

主要介绍几个常见的

1.add&&update

add用于向集合中添加元素，

update将另一个集合合并过来，注意创建集合时我们使用set()

    my_set=set(["java",'python','C','Go','java'])
    my_set.add("scala")
    print(my_set)
    my_set2=set(['PHP','JS'])
    my_set2.update(my_set)
    print(my_set2)


{'Go', 'scala', 'python', 'java', 'C'}
{'Go', 'java', 'C', 'scala', 'PHP', 'JS', 'python'}

2.pop&&remove&&clear

pop()随机删除，没有参数

remove可以删除指定元素，没有返回值，集合中没有删除元素时会报错

clear把集合清空

    my_set=set(["java",'python','C','Go','java'])
    my_set.pop()
    print(my_set)
    my_set.remove('C')#如果上一个操作删除C则报错
    print(my_set)
    my_set.clear()
    print(my_set)

#展示其中一种运行结果
{'Go', 'java', 'C'}
{'Go', 'java'}
set()

集合的运算：

集合的运算与数学中的一致，分为集合和集合，集合和元素

首先看元素和集合，元素与集合只有一种关系：属于或不属于

    my_set=set(["java",'python','C','Go','java'])
    print('java' in my_set )
    print('Java' in my_set)


True
False

再来说集合与集合：比较常见的5种关系

1.A与B相等：==

    my_set=set(["java",'python','C','Go','java'])
    my_set2=set(["java",'python','C','Go'])
    my_set3=set(["java",'python','C'])
    print(my_set2==my_set)
    print(my_set2==my_set3)

True
False

2.A是B的子集：<或issubset()

    my_set=set(["java",'python','C','Go','java'])
    my_set2=set(["java",'python','C','Go'])
    my_set3=set(["java",'python','C'])
    print(my_set2.issubset(my_set))
    print(my_set2<my_set)
    print(my_set3.issubset(my_set2))


True
False
True

3.A和B的并集

A|B或A.union(B)，生成一个新的对象

    my_set=set(["java",'python','C','Go','java'])
    my_set2=set(["js",'python','C','PHP'])
    my_set3=my_set.union(my_set2)
    print(my_set3)

{'C', 'Go', 'js', 'PHP', 'python', 'java'}

4.A和B的交集

a&b或A.intersetction(B)

    my_set=set(["java",'python','C','Go','java'])
    my_set2=set(["js",'python','C','PHP'])
    my_set3=my_set.intersection(my_set2)
    my_set4=my_set&my_set2
    print(my_set3)
    print(my_set4)



{'python', 'C'}
{'python', 'C'}

5.A相对于B的补集

也叫差集，就是属于A但不属于B的元素，用A-B或A.difference(B)

    my_set=set(["java",'python','C','Go','java'])
    my_set2=set(["js",'python','C','PHP'])
    my_set3=my_set.difference(my_set2)
    my_set4=my_set-my_set2
    print(my_set3)
    print(my_set4)


{'java', 'Go'}
{'java', 'Go'}

最后，使用这些运算时最好使用用函数，提高可读性

以上就是python常见的对象类型