python3 之 pthon 基础

此图片木有描述

阳光你好

文章目的:

记录自己学习 python3 过程,并且整理给后来人看,边学边写
以下过程以廖老师的为基础记录

参考链接:

廖雪峰
tutorial
菜鸟教程


Python3 基础语法

1、数据类型和变量

输入:name = input(‘输入并且赋值: ‘)
输出:print(‘hello,’, name)
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=””:
对变量赋值 x = y 是把变量 x 指向真正的对象,该对象是变量 y 所指向的。随后对变量 y 的赋值不影响变量 x 的指向。

我指的也是 y 指的。随后 y 指不指不关我事–我的理解

Python 还允许用 r’’表示’’内部的字符串默认不转义:

>>> print('\\\t\\')
\       \
>>> print(r'\\\t\\')
\\\t\\

2、布尔值可以用 and、or 和 not 运算

not 运算是非运算 真变假
None 表示空值,None 不能理解为 0
在 Python 中,有两种除法,一种除法是 /:

>>> 10 / 3
3.3333333333333335

/ 除法计算结果是浮点数,即使是两个整数恰好整除,结果也是浮点数

还有一种除法是 //,称为地板除,两个整数的除法仍然是整数:

>>> 10 // 3
3

还提供一个余数运算,可以得到两个整数相除的余数:

>>> 10 % 3
1

3、变量

同一个变量可以反复赋值,而且可以是不同类型的变量

a = 123 # a 是整数
print(a)
a = 'ABC' # a 变为字符串
print(a)

a = ‘ABC’

在内存中创建了一个’ABC’的字符串;
在内存中创建了一个名为 a 的变量,并把它指向’ABC’。
把一个变量 a 赋值给另一个变量 b,这个操作实际上是把变量 b 指向变量 a 所指向的数据

a = 'ABC'
b = a
a = 'XYZ'
print(b)

在 Python 中,通常用全部大写的变量名表示常量:P=3.14

多个变量赋值

a, b, c = 1, 2, "runoob"

两个整型对象 1 和 2 的分配给变量 a 和 b,字符串对象 “runoob” 分配给变量 c。

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

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

还可以用 isinstance 来判断:

>>>a = 111
>>> isinstance(a, int)          查 a 是否为 int
True                            真
>>>

您也可以使用 del 语句删除一些对象引用。
del 语句的语法是:

del var
del var_a, var_b
  1. a=1 # 对象 1 被 变量 a 引用,对象 1 的引用计数器为 1
    1. b=a # 对象 1 被变量 b 引用,对象 1 的引用计数器加 1
    2. c=a #1 对象 1 被变量 c 引用,对象 1 的引用计数器加 1
    3. del a #删除变量 a,解除 a 对 1 的引用
    4. del b #删除变量 b,解除 b 对 1 的引用
    5. print(c) #最终变量 c 仍然引用 1

del 删除的是变量,而不是数据。

  1. li=[1,2,3,4,5] #列表本身不包含数据 1,2,3,4,5,而是包含变量:li[0] li1 li2 li3 li4
    1. first=li[0] #拷贝列表,也不会有数据对象的复制,而是创建新的变量引用
    2. del li[0]
    3. print(li) #输出 [2, 3, 4, 5]
    4. print(first) #输出 1

当引用对象的时候,只是指向了它的位置,而原来的路标不用理–个人理解


4、字符串

如果你想连接多个变量或者连接一个变量和一个字符串文本,使用 +:

prefix=Py
>>> prefix + 'thon'
'Python'

这个功能在你想切分很长的字符串的时候特别有用:

>>> text = ('Put several strings within parentheses '
            'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

字符串的截取的语法格式如下:

变量[头下标: 尾下标]

索引值以 0 为开始值,-1 为从末尾的开始位置。
加号 (+) 是字符串的连接符, 星号 (*) 表示复制当前字符串,紧跟的数字为复制的次数。

str = ‘Runoob’ print (str) # 输出字符串 Runoob

print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo

print (str[0]) # 输出字符串第一个字符 R

print (str[2:5]) # 输出从第三个开始到第五个的字符 noo

print (str[2:]) # 输出从第三个开始的后的所有字符 noob

print (str * 2) # 输出字符串两次 RunoobRunoob

print (str + “TEST”) # 连接字符串 RunoobTEST

与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如 word[0] = ‘m’会导致错误。

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


5、list 列表

list 是一种有序的集合,可以随时添加和删除其中的元素。

变量[头下标: 尾下标]

切片的索引有非常有用的默认值;省略的第一个索引默认为零,省略的第二个索引默认为切片的字符串的大小。:

>>> word[:2]  # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]  # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'

对于非负索引,如果上下都在边界内,切片长度就是两个索引之差。例如,word[1:3] 是 2 。

+---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

前 10 个数,每两个取一个:

>>> L[:10:2]
[0, 2, 4, 6, 8]

全部,每 5 个取一个:

>>> L[::5]  
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

len()函数可以获得 list 元素的个数

classmates = ['Michael', 'Bob', 'Tracy']
>>> len(classmates)
3

用 -1 做索引,直接获取最后一个元素:

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates[-1]
'Tracy'

list 是一个可变的有序表,所以,可以往 list 中追加元素到末尾:

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

把元素插入到指定的位置,比如索引号为 1 的位置:

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除 list 末尾的元素,用 pop()方法:

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

删除指定位置的元素,用 pop(i)方法

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

某个元素替换成别的元素,可以直接赋值给对应的索引位置

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list 里面的元素的数据类型也可以不同

>>> L = ['Apple', 123, True]
这是面向对象的写法

list 元素也可以是另一个 list

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)          只有四个
4

要注意 s 只有 4 个元素,其中 s/[2/]又是一个 list

>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
要拿到 'php' 可以写 p[1]或者 s[2][1],因此 s 可以看成是一个二维数组

空的 list,它的长度为 0:

>>> L = []
>>> len(L)
0

list = ['abcd', 786 , 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
['abcd', 786, 2.23, 'runoob', 70.2]

print (list[0])         # 输出列表第一个元素
abcd

print (list[1:3])       # 从第二个开始输出到第三个元素
[786, 2.23]

print (list[2:])        # 输出从第三个元素开始的所有元素
[2.23, 'runoob', 70.2]

print (tinylist * 2)    # 输出两次列表
[123, 'runoob', 123, 'runoob']

print (list + tinylist) # 连接列表
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

列表中的元素是可以改变的:

>>>a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 [] 
>>> a
[9, 2, 6]

List 内置了有很多方法,例如 append()、pop()等等
添加到结尾,默认删除最后一个

• 1、List 写在方括号之间,元素用逗号隔开。
• 2、和字符串一样,list 可以被索引和切片。
• 3、List 可以使用 + 操作符进行拼接。
• 4、List 中的元素是可以改变的。


6、tuple 元祖

不可变的 tuple 有什么意义?因为 tuple 不可变,所以代码更安全。如果可能,能用 tuple 代替 list 就尽量用 tuple。

构造包含 0 个或 1 个元素的元组比较特殊:

tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号

定义一个空的 tuple,可以写成():

>>> t = ()
>>> t
()

定义只有一个数的元祖
必须加一个逗号,

>>> t = (1,)
>>> t
(1,)    

tuple = ('abcd', 786 , 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
('abcd', 786, 2.23, 'runoob', 70.2)

print (tuple[0])          # 输出元组的第一个元素
abcd

print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
(786, 2.23)

print (tuple[2:])         # 输出从第三个元素开始的所有元素
(2.23, 'runoob', 70.2)

print (tinytuple * 2)     # 输出两次元组
(123, 'runoob', 123, 'runoob')

print (tuple + tinytuple) # 连接元组
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似,可以被索引且下标索引从 0 开始,-1 为从末尾开始的位置。也可以进行截取

>>>tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])       索引为 0 的数字
1
>>> print(tup[1:5])         索引为 1 到第五个之前的数字
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):         报错
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

虽然 tuple 的元素不可改变,但它可以包含可变的对象,比如 list 列表。

“可变的”tuple:

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'  跟改的是内存地址
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y']) 

表面上看,tuple 的元素确实变了,但其实变的不是 tuple 的元素,而是 list 的元素。tuple 一开始指向的 list 并没有改成别的 list,所以,tuple 所谓的“不变”是说,tuple 的每个元素,指向永远不变。即指向’a’,就不能改成指向’b’,指向一个 list,就不能改成指向其他对象,但指向的这个 list 本身是可变的!

string、list 和 tuple 都属于 sequence(序列)。

• 1、与字符串一样,元组的元素不能修改。
• 2、元组也可以被索引和切片,方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用 + 操作符进行拼接。


7、条件判断

if 判断条件还可以简写,比如写:

if x:           判断值本身
非零数值、非空字符串、非空 list 等,就判断为 True,否则为 False
print('True')

input:

birth = input('birth: ')
if birth < 2000:
    print('00 前 ')
else:
print('00 后 ')

input()返回的数据类型是 str,str 不能直接和整数比较,必须先把 str 转换成整数

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00 前 ')
else:
    print('00 后 ')

for 循环:

Python 的循环有两种,一种是 for…in 循环,依次把 list 或 tuple 中的每个元素迭代出来:

names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)

所以 for x in …循环就是把每个元素代入变量 x,然后执行缩进块的语句。–我的理解

计算 1-10 的整数之和:

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

第二种循环是 while 循环

计算 100 以内所有奇数之和

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

break 语句可以提前退出循环

n = 1
while n <= 100:
    if n > 10: # 当 n = 11 时,条件满足,执行 break 语句
        break # break 语句会结束当前循环
    print(n)
    n = n + 1
print('END')

continue

通过 continue 语句,跳过当前的这次循环
只打印奇数:

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果 n 是偶数,执行 continue 语句
continue # continue 直接继续下一轮循环,后续的 print()语句不会执行
    print(n)

8、dict 和 set

Dict 字典
Python 内置了字典:dict 的支持 使用键 - 值(key-value)存储, 无序的

列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于: 字典当中的元素是通过键来存取的 ,而不是通过偏移存取。–个人理解是不是指下标??
字典用”{}”标识,它是一个无序的键 (key) : 值(value) 对集合。
键 (key) 必须使用不可变类型。
在同一个字典中,键 (key) 必须是唯一的。

Python 写一个 dict

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

把数据放入 dict 的方法,除了初始化时指定外,还可以通过 key 放入:

>>> d['Adam'] = 67
>>> d['Adam']
67

多次对一个 key 放入 value,后面的值会把前面的值冲掉: 如果 key 不存在,dict 就会报错

避免 key 不存在的错误,有两种办法,一是通过 in

>>> 'Thomas' in d
False

二是通过 dict 提供的 get()方法,如果 key 不存在,可以返回 None

>>> d.get('Thomas')
get()方法返回指定键的值,如果值不在字典中返回默认值 None。
>>> d.get('Thomas', -1)
-1
dict 的 key 必须是不可变对象

构造函数 dict() 可以直接从键值对序列中构建字典如下:

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(Runoob=1, Google=2, Taobao=3)
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

字典类型也有一些内置的函数,例如 clear()、keys()、values()等。 清空和钥匙和值

• 1、字典是一种映射类型,它的元素是键值对。
• 2、字典的关键字必须为不可变类型,且不能重复。
• 3、创建空字典使用 {}。


9、set 集合

无序不重复元素的序列。
使用大括号 {} 或者 set() 函数创建集合

创建一个空集合必须用 set() 而不是 {},因为 {} 是用来创建一个空字典。

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

print(student)   # 输出集合,重复的元素被自动去掉
 {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}

# 成员测试
if('Rose' in student) :
    print('Rose 在集合中 ')
else :
    print('Rose 不在集合中 ')

# set 可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
 {'b', 'a', 'c', 'r', 'd'}

创建一个 set,需要提供一个 list 作为输入集合:也是无序的

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

add(key)方法可以添加元素到 set 中,默认添加到最后一个
remove(key) 方法可以删除元素

两个 set 可以做数学意义上的交集、并集等操作:

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}    他们的相同点
>>> s1 | s2
{1, 2, 3, 4}     他们的不重复的值

print(a - b)     # a 和 b 的差集
 {'b', 'd', 'r'}  


print(a | b)     # a 和 b 的并集
 {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}  


print(a & b)     # a 和 b 的交集
 {'a', 'c'}  


print(a ^ b)     # a 和 b 中不同时存在的元素

{'l', 'r', 'z', 'm', 'b', 'd'}

再议不可变对象
对于可变对象,list 内部的内容是会变化的:

>>> a = ['c', 'b', 'a']
>>> a.sort()   排序
>>> a
['a', 'b', 'c']

对于不可变对象,比如 str,对 str 进行操作

>>> a = 'abc'
>>> a.replace('a', 'A')  a 替换成 A 可以指定第三个参数,最大值
返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串,如果指定第三个参数 max,则替换不超过 max 次。
'Abc'
>>> a
'abc'
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

a 是变量,而’abc’才是字符串对象!对象 a 的内容是’abc’,但其实是指,a 本身是一个变量,它指向的对象的内容才是’abc’:

┌───┐                  ┌───────┐
│ a │─────────────>    │ 'abc' │
└───┘                  └───────┘

调用 a.replace(‘a’, ‘A’)时,实际上调用方法 replace 是作用在字符串对象’abc’上的
虽然名字叫 replace,但却没有改变字符串’abc’的内容
replace 方法创建了一个新字符串’Abc’并返回,如果我们用变量 b 指向该新字符串,就容易理解了,变量 a 仍指向原有的字符串’abc’,但变量 b 却指向新字符串’Abc’了:

┌───┐                  ┌───────┐
│ a │─────────────>    │ 'abc' │
└───┘                  └───────┘
┌───┐                  ┌───────┐
│ b │─────────────>    │ 'Abc' │
└───┘                  └───────┘

对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的 返回值变了


编程的第一步:
写一个生成 菲波那契 子序列的程序

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

用一个逗号结尾就可以禁止输出换行

>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=',')
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

笔记列表:

一般来说,函数的返回值一般为一个。
而函数返回多个值的时候,是以元组的方式返回的。

>>>def example(a,b):
...     return (a,b)
...
>>>type(example(3,4))
<class 'tuple'>

还可以接收可变长参数,比如以 “*” 开头的的参数名,会将所有的参数收集到一个元组上。

def test(*args):
    print(args)
    return args

print(type(test(1,2,3,4)))    #可以看见其函数的返回值是一个元组

字典(小拓展)

不管字典中有多少项,in 操作符花费的时间都差不多。
如果把一个字典对象作为 for 的迭代对象,那么这个操作将会遍历字典的键:

def example(d):
    # d 是一个字典对象
    for c in d:
        print(c)
        #如果调用函数试试的话,会发现函数会将 d 的所有键打印出来;
        #也就是遍历的是 d 的键,而不是值.

输出 kye:value 的组合

for c in dict:
print(c,':',dict[c])
或者
for c in dict:
    print(c,end=':');    结尾分号
    print(dict[c])

type 是用于求一个未知数据类型对象,而 isinstance 是用于判断一个对象是否是已知类型。
可以用 isinstance 判断子类对象是否继承于父类,type 不行。
ype 主要用于判断未知数据类型,isinstance 主要用于判断 A 类是否继承于 B 类:

# 判断子类对象是否继承于父类
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':    直接运行显示代码,作为模块导入则不运行显示
    print (type(son())==father)
False
    print (isinstance(son(),father))
True
    print (type(son()))
<class '__main__.son'>
    print (type(son))
<type 'type'>

------ The Happy Ending ------