PYTHON基础

基本语法

1. 无开头结尾,语句直接不用分号
2. 注释方式

# 第一个注释
# 第二个注释
'''
多行注释
多行注释
'''

1. 代码组

• 代码组,如if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
• 其中不需加{}等符号,区分代码块的方式为首行缩进相同

1. print格式化字符串

• print 默认输出是换行的

#输出多条print
('i 的值为：', i)

x="a"
y="b"
# 换行输出
print( x )
print( y )
# 不换行输出
print( x, end=" " )
print( y, end=" " )

print("%d",%整型)
print("%s",%字符串)
print("%d,%s',%(整型,字符串))

• 格式:print(变量),print(数字),print("字符串")

1. 模块调用

import 模块名

变量与常量

1. 申请变量:变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串
a = b = c = 1
a, b, c = 1, 2, "runoob"

1. 删除变量

del a

1. 对字符串变量的操作

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

keys="i have %s doors and %s rooms"
a=keys%(a,b)#若插入数字则keys%(str(a),str(b))

1. 变量数据类型显式转换(隐式转换和php类似)

int(x [,base])
    将x转换为一个整数

float(x)
    将x转换到一个浮点数

complex(real [,imag])
    创建一个复数

str(x)
    将对象 x 转换为字符串

repr(x)
    将对象 x 转换为表达式字符串

eval(str)
    用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s)
    将序列 s 转换为一个元组

list(s)
    将序列 s 转换为一个列表

set(s)
    转换为可变集合

dict(d)
    创建一个字典。d 必须是一个 (key, value)元组序列。

frozenset(s)
    转换为不可变集合

chr(x)
    将一个整数转换为一个字符

ord(x)
    将一个字符转换为它的整数值

hex(x)
    将一个整数转换为一个十六进制字符串

oct(x)
    将一个整数转换为一个八进制字符串

1. 查看变量类型

print(type(emptyDict))

逻辑与运算

1. 数学运算

   %求余
   x**y    幂 - 返回x的y次幂
   //  取整除 - 向下取接近商的整数

2. 赋值运算

   =   简单的赋值运算符    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
   :=  海象运算符，可在表达式内部为变量赋值。 (没搞懂)

3. 比较运算与php类似

4. 逻辑运算

   x and y 
   布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
   x or y  
   布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
   not x   
   布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

5. 成员运算

   in  如果在指定的序列中找到值返回 True，否则返回 False。     x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
   not in  如果在指定的序列中没有找到值返回 True，否则返回 False。   x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
   如:
   if ( a in list ):
     print ("1 - 变量 a 在给定的列表中 list 中")
   else:
     print ("1 - 变量 a 不在给定的列表中 list 中")
   
   if ( b not in list ):
     print ("2 - 变量 b 不在给定的列表中 list 中")
   else:
     print ("2 - 变量 b 在给定的列表中 list 中")

选择

   ````

   var1 = 100
   if var1:
       print ("1 - if 表达式条件为 true")
       print (var1)

   var2 = 0
   if var2:
       print ("2 - if 表达式条件为 true")
       print (var2)
   print ("Good bye!")

   ````

循环

1. while(不成立则执行else)

   count = 0
   while count < 5:
     print (count, " 小于 5")
     count = count + 1
   else:
     print (count, " 大于或等于 5")

2. for

   sites = ["Baidu", "Google","Runoob","Taobao"]
   for site in sites:
      if site == "Runoob":
          print("菜鸟教程!")
          break
      print("循环数据 " + site)
   else:
      print("没有循环数据!")
   print("完成循环!")

   continue与break的使用与php类似

3. range()函数

   for i in range(5,9) :
      print(i)
   结果:
   5
   6
   7
   8
   
   for i in range(0, 10, 3) :
      print(i)
   结果:
   0
   3
   6
   9
   
   a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
   for i in range(len(a)):
      print(i, a[i])
   结果:
   0 Google
   1 Baidu
   2 Runoob
   3 Taobao
   4 QQ

数组

1. 列表

   list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
   print( list[0] )
   print( list[1] )
   print( list[2] )
   
   nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
   print(nums[0:4])
   结果:[10, 20, 30, 40]
   
   插入列表
   list1.append('Baidu')#在末尾插入
   
   删除列表
   del list[2]
   
   函数大全
   1   len(list)
   列表元素个数
   
   2   max(list)
   返回列表元素最大值
   
   3   min(list)
   返回列表元素最小值
   
   4   list(seq)
   将元组转换为列表
   
   1   list.append(obj)
   在列表末尾添加新的对象
   
   2   list.count(obj)
   统计某个元素在列表中出现的次数
   
   3   list.extend(seq)
   在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
   
   4   list.index(obj)
   从列表中找出某个值第一个匹配项的索引位置
   
   5   list.insert(index, obj)
   将对象插入列表
   
   6   list.pop([index=-1])
   移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
   
   7   list.remove(obj)
   移除列表中某个值的第一个匹配项
   
   8   list.reverse()
   反向列表中元素
   
   9   list.sort( key=None, reverse=False)
   对原列表进行排序
   
   10  list.clear()
   清空列表
   
   11  list.copy()
   复制列表

2. 元组

   元组与列表类似，不同之处在于元组的元素不能修改。

   元组使用小括号 ( )，列表使用方括号 [ ]。

   元组只有一个元素需要tup(1,)加逗号

   tup1 = (12, 34.56)
   tup2 = ('abc', 'xyz')
   
   # 创建一个新的元组
   tup3 = tup1 + tup2
   print (tup3)

   元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

   1   len(tuple)
   计算元组元素个数。   
   
   2   max(tuple)
   返回元组中元素最大值。     
   
   3   min(tuple)
   返回元组中元素最小值。     
   
   4   tuple(iterable)
   将可迭代系列转换为元组。    
   
   >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
   >>> tuple1=tuple(list1)
   >>> tuple1
   ('Google', 'Taobao', 'Runoob', 'Baidu')

3. 字典

   字典由键和值组成一一对应关系,值可变,但键不可变

   d = {key1 : value1, key2 : value2, key3 : value3 }

   字典可添加也可修改

   tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
   
   tinydict['Age'] = 8               # 更新 Age
   tinydict['name'] = "菜鸟教程"  # 添加信息

   字典的清除

   del tinydict['Name'] # 删除键 'Name'
   tinydict.clear()     # 清空字典
   del tinydict         # 删除字典

   字典输出

   str(dict)
   输出字典，可以打印的字符串表示。(也可和其他一样直接print)

4. 集合

   创建与修改

   parame = {value01,value02,...}
   a = set('abracadabra')即a={'a', 'r', 'b', 'c', 'd'}
   
   >>> a - b                              # 集合a中包含而集合b中不包含的元素
   {'r', 'd', 'b'}
   >>> a | b                              # 集合a或b中包含的所有元素
   {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
   >>> a & b                              # 集合a和b中都包含了的元素
   {'a', 'c'}
   >>> a ^ b                              # 不同时包含于a和b的元素
   {'r', 'd', 'b', 'm', 'z', 'l'}
   
   s.add( x )
   将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。x 可以有多个，用逗号分开。
   s.remove( x )
   将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

5. 常用函数

   len(s)计算元素数目
   s.clear()清空集合
   x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

6. 迭代

   迭代器有两个基本的方法：iter() 和 next()。

   字符串，列表或元组对象都可用于创建迭代器

   list=[1,2,3,4]
   it = iter(list)    # 创建迭代器对象
   print (next(it))   # 输出迭代器的下一个元素
   1
   print (next(it))
   2
   
   迭代器对象可以使用常规for语句进行遍历：
   实例(Python 3.0+)
   #!/usr/bin/python3
   
   list=[1,2,3,4]
   it = iter(list)    # 创建迭代器对象
   for x in it:
      print (x, end=" ")
   
   list=[1,2,3,4]
   it = iter(list)
   i=1;
   while i<=len(list):
      print (next(it))
      i++

   类的迭代
   把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
   
   class MyNumbers:
    def __iter__(self):
      self.a = 1
      return self
   
    def __next__(self):
      x = self.a
      self.a += 1
      return x
   
   myclass = MyNumbers()
   myiter = iter(myclass)
   
   print(next(myiter))
   print(next(myiter))
   print(next(myiter))
   print(next(myiter))
   print(next(myiter))
   
   执行输出结果为：
   
   1
   2
   3
   4
   5

   迭代异常

   StopIteration 用于标识迭代的完成，防止出现无限循环的情况，

函数

1. 定义函数:

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

1. 局部与全局变量:

函数内修改全局变量要用global申明(与php类似)如果不申明视为开辟一个同名的局部变量
函数外无使用局部变量,需要可以用return()输出

1. 函数传参

def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return

类

类的申请与调用

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

request库

基础使用

# 导入 requests 包
import requests

# 发送请求
x = requests.get('https://www.runoob.com/')

# 返回网页内容
print(x.text)

响应信息

apparent_encoding   编码方式
close()     关闭与服务器的连接
content     返回响应的内容，以字节为单位
cookies     返回一个 CookieJar 对象，包含了从服务器发回的 cookie
elapsed     返回一个 timedelta 对象，包含了从发送请求到响应到达之间经过的时间量，可以用于测试响应速度。比如 r.elapsed.microseconds 表示响应到达需要多少微秒。
encoding    解码 r.text 的编码方式
headers     返回响应头，字典格式
history     返回包含请求历史的响应对象列表（url）
is_permanent_redirect   如果响应是永久重定向的 url，则返回 True，否则返回 False
is_redirect     如果响应被重定向，则返回 True，否则返回 False
iter_content()  迭代响应
iter_lines()    迭代响应的行
json()  返回结果的 JSON 对象 (结果需要以 JSON 格式编写的，否则会引发错误)
links   返回响应的解析头链接
next    返回重定向链中下一个请求的 PreparedRequest 对象
ok  检查 "status_code" 的值，如果小于400，则返回 True，如果不小于 400，则返回 False
raise_for_status()  如果发生错误，方法返回一个 HTTPError 对象
reason  响应状态的描述，比如 "Not Found" 或 "OK"
request     返回请求此响应的请求对象
status_code     返回 http 的状态码，比如 404 和 200（200 是 OK，404 是 Not Found）
text    返回响应的内容，unicode 类型数据
url     返回响应的 URL

如：print(x.reason)

request方法

delete(url, args)   发送 DELETE 请求到指定 url
get(url, params, args)  发送 GET 请求到指定 url
head(url, args)     发送 HEAD 请求到指定 url
patch(url, data, args)  发送 PATCH 请求到指定 url
post(url, data, json, args)     发送 POST 请求到指定 url
put(url, data, args)    发送 PUT 请求到指定 url
request(method, url, args)  向指定的 url 发送指定的请求方法

如：

#导入 requests 包
import requests

kw = {'s':'python 教程'}

# 设置请求头
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}

# params 接收一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode()
response = requests.get("https://www.runoob.com/", params = kw, headers = headers)

# 导入 requests 包
import requests

kw = {'s':'python 教程'}

# 设置请求头
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}

# params 接收一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode()
response = requests.get("https://www.runoob.com/", params = kw, headers = headers)