Python学习笔记_1

一、基础知识

1. 基础：

数据结构：常量、变量、元组（列表）、字典

数据类型：int float str

算法：分支和循环

面向对象：类、属性、方法

封装、继承、多态

2. python语言的特点：

例子：定义三个不同类型的变量，赋值，输出

无头文件、无主函数、无大括号、无分号，简洁，靠缩进来区分语句，且变量的定义不需要书写类型，直接赋值，Python自动识别数据类型，字符串赋值时可用双引号或单引号，两者区别：双引号可用于打印对象中含有单引号时

注释：单行注释---#，多行注释---’’’(一对缩进相同)

注意：不要用一些关键字命名：selenium

3. 输入输出函数：

1）输入函数：input       a=input(“请输入：”)      print(a)

① input函数自动识别数据类型

② 多个数据同时输入：a,b = input('请输入：').split()

③ input函数输入的所有数据都为str类型

④ 数据类型查看函数：type(变量名)

a=input(“请输入：”)       print(type(a))     运行结果：<class 'str'>

⑤ 限制只能输入整数
a = int(input('please input a num:'))

2）输出函数：print('结果为：',a,b)

print( ("%d,%f,%s")%(a,b,c)) –字符串采用%s

4. 元组（tuple）：

1） 定义：   a = (1,3.14,'hello')

定义一个1-999的元组 ：a = list(range(1,1000))

2）引用方式：

① 整体引用：print(a)

② 下标引用：print(a[1])  运行结果：3.14  -- []为下标，下标从0开始

③ 下限、上限、步长：  print（1:2:1）   运行结果：（3.14）

下限表示从谁a[1]打印，上限表示打印到谁a[2]，但是该数默认不打印，步长是下一元素的增量，步长为1可省略

④ 特殊引用：

print(s[-2])    -- 输出倒数第2个数

print(s[1::2])  -- 下限不写代表打印到最后

⑤ 练习：定义一个1-9的元组list，1、输出倒数第3个元素；2、输出值468
a = (1,2,3,4,5,6,7,8,9)
print(a[-3])
print(a[3],a[5],a[7])

3）常用操作：

① 逆序存放：s.reverse()---改变原来元组的值

② 排序存放：s.sort()------改变原来元组的值

③ 排序：sorted(s)---------不改变原来元组的值，只返回一个排序结果

④ 插入：s.insert(n,m)-----在某一位置(s[n]前面)插入该值m

⑤ 追加：s.append(n)-------在该元组末尾追加n

5. 列表（list）：

1）定义：   b = [1,3.14,'world']    print(b)

2）range(n)：产生一个0到n-1的列表

range(m,n)：产生一个m到n-1的列表

range(m,n,i)：产生一个m到n-1，步长为i的列表

输出：list(range(1,1000))

3）查看数据类型：   print(type(b))     运行结果：<class 'list'>

4）元组和列表区别：

① 元组不可变，列表可变

② 元组不可增、删、改，列表可以进行增、删、改

5）常用操作：

① 连接两个列表：m.extend(n) ---将m和n两个列表连接

② 删除指定元素：m.pop(n) ------删除m[n]并返回该值

删除指定元素第一次出现的值：m.remove(n) –将第一次出现的元素n删除

删除：del s[n] ----删除s[n]，n为下标

③ 返回该值在列表中出现的次数：m.count(n) –返回元素n在列表中出现的次数

④  返回列表中元素最大值：max(s)

返回列表中元素最小值：min(s)

⑤ 长度：len(s) ---返回列表元素的个数

⑥ 获得元素的下标：s.index(n) -------得到元素n在列表中的下标

⑦ 清空列表：s.clear() --------清空列表

⑧ in 和 not in ---用来检查是否在列表中

6）练习：

① 求列表[11,13,5,7,0,56,23,34,72]中的最大值、最小值及列表中一共有几个元素

a = [11,13,5,7,0,56,23,34,72]
print(max(a))
print(min(a))
print(len(a))
② 获取56在元素中的位置
print(a.index(56))
③ 追加元素7
a.append(7)
print(a)
④ 删除元素0
del a[4]
print(a)
⑤ 排序列表，由大到小
a.sort()
a.reverse()
print(a)
⑥ 将列表[66,67,68]与原列表组合
b = [66,67,68]
b.extend(a)
print(b)

⑦ 将列表s去重并有小到大排列输出
s = [4,1,2,3,2,1]
m = set(s) #先转化成集合
print(m)
m = list(set(s)) #再转化成列表，列表是有序的有下标
print(m)

6. 字典（dict）：

1) 定义：  大括号，键值对形式存在{‘key’:value}

c = {'a':10,'b':15,'c':20}    print(c)

2) 查看数据类型： print(type(c))     运行结果：<class 'dict'>

3）引用：典内的元素没有顺序，不能够通过下标引用，能通过键来引用或整体引用

print(s['c'])；print(s)

4）赋值：当key不存在时即可为字典插入，但是如果存在，即为修改。s['d']=11

5）操作方法：

① 取出所有的键：s.keys()

② 取出所有的值：s.values()

③ 取出所有的键值对，作为一个元组内的元素：s.items()

④ 清空字典：s.clear()

⑤ 删除：del s[‘key’]

7.集合

1）定义：s = {3,1,2}，集合是无序的，且不重复，不能通过下标引用

2）引用：不能通过下标引用

3）操作：

① 添加-s.add(n)---向集合s添加元素n

② 删除-s.remove(n) ----删除集合中的元素n，如果元素不存在，报Keyerror异常

③ 删除-s.discard(n) ----删除集合中的元素n

④清空-s.clear() ------清空集合

⑤ in 和 not in ---用来检查是否在集合中

in 和not in --用于检查是否在集合中;

8.整体练习题：

1）倒序输出 -- 改变原来元组的值　　
a = [1,2,3,4,5]
a.reverse()
print(a)
2）对原列表进行排序-从小到大
a = [6,2,5,4,3,1]
a.sort()
print(a)
3）不改变原来元组的值，只返回一个排序结果
a = [6,2,5,4,3,1]
print(sorted(a))
print(a)
4）在4的前面插入元素a
a = [6,2,5,4,3,1]
a.insert(3,'a')      #3是4的下标
print(a)
5）追加-在末尾追加
a = [6,2,5,4,3,1]
a.append(11)
print(a)
6）连接2个列表
a = [6,2,5,4,3,1,2,4,2]
b = ['a','b','c']
a.extend(b)
print(a )
7）删除5这个元素
a.pop(2)
print(a)
8）删除元素2第一次出现的值
a.remove(2)
print(a)
9）返回元素2在列表中出现的次数
print(a.count(2))

10）返回列表中元素的最大值、最小值、个数
print(max(a)) 
print(min(a))
print(len(a))
11）删除下标为1的元素
del a[1]
print(a)
12）返回元素的下标
print(a.index(4))

13）列表[1,2,3,4,3,4,2,5,5,8,9,7],将此列表去重，得到一个唯一元素的列表

m = [1,2,3,4,3,4,2,5,5,8,9,7]
m = list(set(m))
print(m)

9. 分支：

分类	If-分支	If-else分支	If-elif嵌套
语法	If 条件： 语句体	If 条件： 语句体1 else： 语句体2	If 条件1： 语句体1 elif 条件2： 语句体2 elif 条件3： 语句体3 else： 语句体
例子	a=0 if a>0: a+=1 print a	a=input() if a>0: a+=1 else: a-=1 print a	a=input() if a>0: a+=1 elif a==0: a-=1 elif a<0: a+=2 print a

1）例1：a>0,则加10，a=0,加20，a<0,加30，只能输入数字

try:
    a = int(input('please input a num:'))
    if a > 0:
        a += 10
    elif a == 0:
        a += 20
    else:
        a += 30
    print(a)
except ValueError:
    print('请输入数字！')

2）例2：输入一个数，判断该数的等级：90-100：等价为A……60以下：等级为E

（注：Python不支持&&、||，需要and、or代替，同时也支持多个条件连接：0<a<10）

n = 100
while n > 0:
    a = int(input('please input a num:'))
    if a >= 90 and a < = 100:
        print('等级为A')
    elif a >= 80 and a < 90:
        print('等级为B')
    elif a >=70 and a < 80:
        print('等级为C')
    elif a >= 60 and a < 70:
        print('等级为D')
    else:
        print('等级为E')
    n -= 1

10.循环

1）循环四要素：① 定义循环变量 ② 循环条件 ③ 循环体 ④ 循环变量发生变化

n = 0;            n<5;          print n;          n+=1

2）把程序做成循环的步骤：

① 确定循环体，全部选中用Tab键内推，用循环结构包裹

②从上到下依次编写：①/②/④

3）While 循环：

① 语法：

循环变量

　　while 条件：

循环体

循环变量发生变化

② 举例：

i=0

while i<5:

print i

i=i+1

③ 练习：求1-100的和：

a = 0
n = 1
while n <= 100:
    a = a + n
    n += 1
print(a)

运行结果：5050 

4）for 循环：

① 语法：

for 变量 in 序列:

循环体

② 举例：依次打印列表中的元素

for i in [1,2,3,4]:
    print(i,'ok')

运行结果：

1 ok
2 ok
3 ok
4 ok

for的用法：

dict ={'a':1,'b':2,'c':3}
print(dict.items())
运行结果为：

dict_items([('a', 1), ('b', 2), ('c', 3)])

for x,y in [(1,2),(3,4),(5,6)]:
   print('x和y的值分别是：',x,y)
运行结果为：

x和y的值分别是： 1 2
     x和y的值分别是： 3 4
     x和y的值分别是： 5 6

③ range（n）：产生一个0到n-1的序列

range(m,n)：产生一个m到n-1的序列

range(m,n,i)产生一个m到n-1且步长为i的序列

④ 练习：

打印1-10的数字

for i in range(1,10):  #不包含10
    print(i)

输出结果：

1
2
3
4
5
6
7
8
9

打印1-1000的奇数

for i in range(1,1000,2):
    print(i)

5）continue 和 break

① continue：停止当前这次循环，继续下次循环

打印1-5的数字，遇到3的时候不打印

for i in range(1,6):
    if i == 3:
        continue
    print(i)

运行结果：

1
2
4
5

② break：跳出所有循环

打印1-5的数字，遇到3的时候跳出循环

for i in range(1,6):
    if i == 3:
        break
    print(i)

运行结果：

1
2

练习题：

① 求10的阶乘

a = 1
i = 1
while i <= 10:
    a = a * i
    i += 1
print('10的阶乘为：',a)

运行结果：10的阶乘为： 3628800

计算任意数的阶乘

x = 1
y = int(input("请输入要计算的数:"))
for i in range(1, y + 1):
   x = x * i
print('输入数的阶乘为：',x)

② 求100以内能被3整除的数

n = 1
for i in range(1,100):
    if i % 3 == 0:
        print(i)
    else:
        n += 1

③ 求斐波那切数列（1,1,2,3,5,8,13,21...）：

a = 1
b = 1
i = 0   # i=2

if i == 1:
    print(a,end=',')
else:
    print(a,end=',')
    print(b,end=',')
    while i < 10:
        c = a + b
        print(c,end=',')
        a = b
        b = c
        i += 1
运行结果：1,1,2,3,5,8,13,21,34,55,89,144,

求斐波那契数列，并以列表的形式输出：

a = 1
b = 1
i = 0
lists = []
if i == 1:
    print(a)
else:
    lists.append(a)
    lists.append(b)
    while i < 10:
        c = a + b
        lists.append(c)
        a = b
        b = c
        i += 1
    print(lists)

运行结果：[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]

输出任意项的斐波那契数列：

array = int(input("请输入你需要多少项斐波那契数列："))
a = 1
b = 1
i = 2
if array <= 0:
    print("请输入一个大于等于1的正整数！")
elif i == 1:
    print("斐波那切数列为：")
    print(a,end=',')
else:
    print("斐波那切数列为：")
    print(a,end=',')
    print(b,end=',')
    while i < array:
        c = a + b
        print(c,end=',')
        a = b
        b = c
        i += 1

④ 输出100以内的所有质数（2,3,5,7,11,13,17,19...）（只能被1和其本身整除的数）

lists = []
i = 2
for i in range(2,100):
    n = 2
    for n in range(2,i):
        if i % n == 0:
            break
    else:
        lists.append(i)
print(lists)

运行结果：[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]