Python入门学习笔记1-Python基础

Python入门学习笔记1-Python基础

前言：本文介绍了Python学习的前导知识概念以及必记基础函数，如善用help方法查看帮助文档，以及内置对象类型的概念以及常用函数的详解。

一、Python前导知识概念
1、什么是Python内置对象类型？

 Python已经定义的一些数据类型。

2、Python内置对象类型包括如下：

 整数、浮点数、字符串、列表、元祖、字典、集合。

3、什么是Python内置函数？

 Python已经定义的函数。

4、Python内置函数包括如下：

更多详细Python内置函数请参见官方文档：

5、常用内置函数介绍：
Tip：以下代码均是在cmd的Python交互界面书写并运行的。“开始–>运行（cmd）–>python”进入Python交互界面

5.1 type(object)

返回一个对象类型，例如：

>>> type(2)
<class 'int'>

可以看到这个方法返回2是一个int类型的数据

5.2 help(object)

返回某对象的帮助文档，例如
非常重要

>>> help(id)
Help on built-in function id in module builtins:

id(obj, /)
    Return the identity of an object.

    This is guaranteed to be unique among simultaneously existing objects.
    (CPython uses the object's memory address.)

返回id这个函数的相应说明。

5.3 round（number [，ndigits ] ）

number ==> 数字

ndigits ==> 保留几位数

例如：

>>> round(0.1+0.2, 2)
0.3

返回的是0.3

如果我们直接print(0.1 + 0.2)，返回的结果是0.30000000000000004。

>>> print(0.1 + 0.2)
0.30000000000000004

我们知道0.1+0.2=0.3，但是由于进制转换的原因变成了0.30000000000000004，因此我们四舍五入就能解决。

6、 四则运算

加(+)减(-)乘(*)除(/)、取余(%)取商(//)

二、Python内置对象类型详解

1、 字符/字符串
1.1 描述
用一对单引号或者双引号进行包裹，例如

name="pan"
addr='gx'

tip：单引号、双引号要成对出现。如下

'what's you name'

这样会报语法错误，原因是电脑识别到了又三个单引号，前面两个配对之后后面一个就单了，也就不符合成对出现的原则。那应该怎么解决呢？可以这样
“what's you name”
或这样
‘what“s you name’
这样就不会报错。最外面的如果是单引号里面就不要再使用单引号，反则也一样。

2、字符串相关函数
2.1 在字符串里+号是连接符/拼接符
例如：

n="python"
m="book"
n+m

输出”pythonbook“
而这个”pythonbook“其实是一个新对象，不是n也不是m

2.2 len(str/object)
返回字符串的长度，例如

>>> n = "python"
>>> len(n)
6
>>> len("python")
6

返回结果都是 6

2.3 字符串的索引
'str' in object
返回一个boolean值，存在则返回true 否则返回false，例如

>>> n = "python"
>>> 'p' in n
True

返回true，证明n这个对象的字符串里存在‘p’这个字符

str.index('str')
返回某字符串的下标。从左向右搜索，返回遇到的第一个对于字符的下标。如下：

>>> str = ”python book“
>>> str.index("o")
4

返回结果是一个int值，4表述‘o’在这个字符串中的位置下标，下标从0开始。

2.4 字符的切片
字符串可以通过下标直接
str[startIndex: endIndex: stepLength ]

• str 字符串
• startIndex 开始下标（从左边开始下标第一个是0，从右边开始下标第一个是-1）
• endIndex 结束下标 （含头不含尾，假设截取0到3的字符串，实际上只能截取到0-2的字符串）
• stepLength 步长。（如果不填则默认是1，也就是连续的。那么如果填个2那就是隔空截取）
  例子如下：

>>> r = "python book"
>>> r
'python book'
>>> len(r)
11
>>> r[0]
'p'
>>> r[-1]
'k'
>>> r[1:9]
'ython bo'
>>> r[0:9:1]
'python bo'
>>> r[0:9:2]
'pto o'
>>> r[:9:2]
'pto o'
>>> r[2::]
'thon book'
>>> r[:]
'python book'
>>> r[::-1]
'koob nohtyp'
>>> r[::-2]
'ko otp'
>>>

Tip：字符串切片（截取）实际上是copy创建一个新的对象，对原本的字符串对象是没有影响的。
实现这个功能的还有一个方法，str.split(obj/str) 按照某种规则进行切割字符串，下面这个例子是按照空格进行切割的，返回的是一个字符串列表，如下：

>>> str = "python book"
>>> str
'python book'
>>> str.split(" ")
['python', 'book']

字符串占位符

>>> "I like {0} and {1}".format("python", "phpcice")
'I like python and phpcice'

Tip：这个代码里的{0}和{1}就相当于一个占位符，占位符可以理解为就是占据一个空间或者位置。

设置占位字符长度，以及设置文本对齐方式
如下：

>>> "I like {0:10} and {1:>15}".format("python", "phpcice")
'I like python     and         phpcice'

{0:10} 10代表的是字符长度。
{1: >15} >代表右对齐，^居中，<左对齐。默认就是左对齐

Tip：一个重要的函数 dir(object)
查看某对象的成员函数及对象有哪些
例如你想知道str到底还有哪些方法你可以用这个dir(str)函数进行查看，就能看到如下结果。

从上面的截图可以看出关于字符串的函数还有很多，如果感兴趣可以自己去学习。

3、列表

列表什么元素都能装，同一个列表可以装各种不同的元素，但是通常只会装一种。

列表是有序的，所以它具有序列的操作特点。

列表能通过下标赋值修改元素，而字符串不可以。如，列表lst[0]="12" 成功，字符串str[0]="12"失败

列表的基本操作函数如索引、切片等均与字符串相同。

定义：listName = [object]如下，

lst = [1,2,3,4,5,6]

列表的常用函数

3.1 向列表中增加元素

末端增加一个元素

​ list.append(element)

​ 参数：list 列表名； element 要添加的元素
例子如下：

>>> lst = [1,2,3,4,5,6]
>>> lst
[1, 2, 3, 4, 5, 6]
>>> lst.append("7")
>>> lst
[1, 2, 3, 4, 5, 6, '7']

在索引前面插入一个元素

​ list.insert(index, element)

​ 参数：list 列表名；index要插卡位置，即下标；element被插入的元素
例子如下：

>>> lst
[1, 2, 3, 4, 5, 6, '7']
>>> lst.insert(1,12)
>>> lst
[1, 12, 2, 3, 4, 5, 6, '7']

通过可迭代的对象来扩展列表

​ list.extend(iterable)

​ 参数：list 源列表名；iterable可迭代元素，如字符串“12348565”
例子如下：

>>> lst
[1, 12, 2, 3, 4, 5, 6, '7']
>>> str = "abcdef"
>>> lst.extend(str)
>>> lst
[1, 12, 2, 3, 4, 5, 6, '7', 'a', 'b', 'c', 'd', 'e', 'f']

3.2 删除列表中的元素

 删除某个指定元素，并返回被删除元素的值。

list.pop(element)

不填参数时默认删除列表最后一个元素
例子如下：

>>> lst
[1, 12, 2, 3, 4, 5, 6, '7', 'a', 'b', 'c', 'd', 'e', 'f']
>>> lst.pop(7)
'7'
>>> lst
[1, 12, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f']
>>> lst.pop()
'f'
>>> lst
[1, 12, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e']

删除某个指定的元素，没有返回值。必须指定元素

list.remove(element)

例子如下：

>>> lst
[1, 12, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e']
>>> lst.remove('e')
>>> lst
[1, 12, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']

删除整个列表的元素。

list.clear()

例子如下：

>>> lst
[1, 12, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']
>>> lst.clear()
>>> lst
[]

tip: list=[]也能达到clear的效果，但是他们是有本质的区别的。list=[]重新赋值一个空列表以达到效果，此时的这个list其实已经不是之前的那个list了，相当于是新建了一个list，其与之前的list指向的内存地址不同了。但是clear前后指向的都是同一个地址。

>>> lst = [1,2,3,4]
>>> lst = []
>>> lst
[]

3.3 列表排序

list.sort()

只能对同一种元素进行排序。默认是升序。若想降序排序需要将参数 reverse=True即可。list.sort( reverse=True)
例子如下：

>>> lst = [2,1,9,4,3,15,21,36,11,5]
>>> lst
[2, 1, 9, 4, 3, 15, 21, 36, 11, 5]
>>> lst.sort()
>>> lst
[1, 2, 3, 4, 5, 9, 11, 15, 21, 36]
>>> lst.sort(reverse=True)
>>> lst
[36, 21, 15, 11, 9, 5, 4, 3, 2, 1]

list.reverse()

反序排序，即将整个列表的元素全部反过来。

例子如下：

>>> lst
[36, 21, 15, 11, 9, 5, 4, 3, 2, 1]
>>> lst.reverse()
>>> lst
[1, 2, 3, 4, 5, 9, 11, 15, 21, 36]

4、元祖

类似列表。
列表用“[]”中括号定义，元祖用“()”小括号定义。
与列表相同元祖能放任何数据类型。
当元祖只有一个元素时，元素后必须添加一个逗号“,”，否则不是元祖，而且字符串。
元祖也是一个序列，一次元祖也具有序列的一般方法，例如index函数
元祖是不可变对象，不能像列表一样通过下标修改元素值。可以向元祖转成列表在修改，修改完在转回来。

4.1 定义元祖

>>> t = (1,2,"python",[1,2,3])
>>> type(t)
<class 'tuple'>

4.2 索引与切片

与前面的列表一样，参照前面的例子。

5、字典
5.1 字典的定义

>>> d = {'name':'pan','age':'22','city':'nanning'}
>>> d
{'name': 'pan', 'age': '22', 'city': 'nanning'}
>>> dict(a=1,b=2,c=3)
{'a': 1, 'b': 2, 'c': 3}

Tip：字典是以键值对（key-value）的形式进行存值的。key不能重复，key通常是不可变的一个关键字，并且能唯一识别一个元素的。

5.2 字典的基本操作

取值

通过key来获取某一个键值对的值value，如：

>>> d['name']
'pan'

修改元素

通过key修改指定的元素值，如下：

>>> d
{'name': 'pan', 'age': '22', 'city': 'nanning'}
>>> d['name'] = "ruihe"
>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning'}

更新/添加元素

dictName.update(object) ，例子如下：

>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning'}
>>> d.update(sal="6000")
>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning', 'sal': '6000'}

删除元素

del dictName[key]
删除指定元素，无返回值

>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning', 'sal': '6000'}
>>> del d['sal']
>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning'}

dictName.pop(key)
删除指定元素，并返回删除元素的value值。

>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning'}
>>> d.pop('city')
'nanning'
>>> d
{'name': 'ruihe', 'age': '22'}
>>> d.pop('city','已经不存在了')
'已经不存在了'
>>> d
{'name': 'ruihe', 'age': '22'}

dictName.popitem()

删除字典末端的元素，并返回剩下的字典元素。

Tip：这个方法在3.6之前Python版本中是随机删除一个元素，在3.6之后则是删除字典中最后一个元素。

>>> d.popitem()
('age', '22')

5.3 字典的两个重要的方法
当我们查看一个不存在的key值时，代码会报错，这样可能会终止我们的程序或者出现一些不可预计的错误，如下：

>>> d['aa']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'aa'

该如何解决呢？

dictName.get(key,tipStr)
参数：key 字典元素的key tipStr 没有找到key时返回给用户的提示语。如果不填tipStr 就没有提示语。
这样程序不会报错，并且也有良好的交互。

>>> d.get('aa')
>>> d.get('aa','没有该元素')
'没有该元素'

同样的效果的还有一个方法，如下：
dictName.setdefault(key,tipStr)

>>> d.setdefault('aa','没有所以创建')
'没有所以创建'
>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning', 'sal': '6000', 'aa': '没有所以创建'}

不同之处在于，当没有找到对应的key的时候，会根据搜索的key和提示语创建一个新元素。如果不填提示语也会创建一个对应的元素，值为None。如下：

>>> d.setdefault('bb')
>>> d
{'name': 'ruihe', 'age': '22', 'city': 'nanning', 'sal': '6000', 'aa': '没有所以创建', 'bb': None}

5.4 字典与列表的区别
字典不是序列
两者都是容器类对象
两者都是可变对象
Python3.6开始，字典也有顺序

6、集合
6.1 集合的定义

可变集合的定义

>>> s = set([1,2,3,4,5,1,2])
>>> s
{1, 2, 3, 4, 5}
>>> type(s)
<class 'set'>
>>> s2 = {"python",2,3}
>>> type(s2)
<class 'set'>

不可变集合的定义

不可变的集合里面有add，pop，remove等对于集合的基本操作。

>>> f3 = frozenset('panruihe')
>>> f3
frozenset({'h', 'p', 'r', 'i', 'a', 'e', 'n', 'u'})

6.2 可变集合的基本操作。

添加元素

set.add(object)例子如下：

>>> s2
{3, 2, 'python'}
>>> s2.add('php')
>>> s2
{3, 2, 'python', 'php'}

删除元素

set.pop()
删除首位元素，例子如下：

>>> s2
{3, 2, 'python', 'php'}
>>> s2.pop()
3
>>> s2
{2, 'python', 'php'}

set.remove(element)
删除指定元素，例子如下：

>>> s2
{2, 'python', 'php'}
>>> s2.remove(2)
>>> s2
{'python', 'php'}

set.discard(element)
删除指定元素，例子如下：

>>> s2
{'python', 'php'}
>>> s2.discard('php')
>>> s2
{'python'}

Tip：remove和discard都是删除指定元素，那他们俩的区别是什么呢？remove删除一个不存在的元素时会不错，而discard删除一个不存在的元素时不会报错。如下：

>>> s2
{'python'}
>>> s2.remove('php')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'php'
>>> s2.discard('php')