Python 验证数据库字段 python 检查数据类型

循环和判断

1.if

• 形式

1 if condition_1:
2     statement_block_1
3 elif condition_2:
4     statement_block_2
5 else:
6     statement_block_3

 

• 说明
  如果 condition_1 为 True 将执行 statement_block_1 块语句
  如果 condition_1 为False，将判断 condition_2
  如果condition_2 为 True 将执行 statement_block_2 块语句
  如果 condition_2 为False，将执行statement_block_3块语句
• 举例：

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
#pyversion:python3.5
#owner:fuzj


info = {"fuzj":"123123","jeck":"123123"}

user = input("Username: ")
passwd = input("Password: ")


if user in info.keys() and passwd == info[user]:
    print("Username is correct...")
    print("Welcome to Login....")
else:
    print("Username or Password is invalid...")

 

［具体请点击这里](http://www.runoob.com/python3/python3-conditional-statements.html )

2.for

• 形式

for <variable> in <sequence>:
    <statements>
else:
    <statements>

• 举例

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#pyversion:python3.5
#owner:fuzj


age = 22
m = 0
for i in range(10):
    guess_num = int(input("Your age: "))
    if m < 3:
        if guess_num == age:
            print("your are right...")
            break
        elif guess_num > age:
            print("too big...")
        else:
            print("too small...")
    else:
        re = input("do you want to contine: (y/n),you have %s chance " % (9-i))
        if re == "y":
            m = 0
            continue
        else:
            print("you are lower")
            break
    m += 1

［具体请点击这里](http://www.runoob.com/python3/python3-loop.html)

3.wile

• 举例

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#pyversion:python3.5
#owner:fuzj


count = 0
while True:
    count += 1
    if count > 10 and count < 15:
        continue
    if count < 20:
        print("fuzj",count)
    else:
        break

 

4.break和continue

• 作用
  break：跳出当前的循环体，不在继续后面的循环，可用在while循环和for循环中
  continue：跳出当前的循环，继续下一次循环，可用在while循环和for循环中
• 举例：

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#pyversion:python3.5
#owner:fuzj


count = 0
while True:
    count += 1
    if count > 10 and count < 15:
        continue
    if count < 20:
        print("fuzj",count)
    else:
        break

 

数据类型

1.数字

数字提供了标量存储和直接访问，它是不可更改类型，如果变更数字的值会生成新的对象

• 数值类型

• 整型(int)：在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807
• 长整型(long):或长，是无限大的整数，这样写整数，后面跟着一个大写或小写的L。从python3起，取消了长整型的概念
• 浮点型（float）：浮点数用来处理实数，即带有小数的数字
• 复数（complex）：由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257
下面表说明以上概念

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323	15.20	-.6545+0J
-20	0122L	32.3+e18	4.53e-7j

• 内置函数

• 数学函数

• abs(x) 返回数字的绝对值，如abs(-10) 返回 10
• ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
• cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
• exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
• fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
• floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
• log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
• log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
• max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
• min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
• modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
• pow(x, y) x**y 运算后的值。
• round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
• sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

• 随机数函数

• choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
• randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
• random() 随机生成下一个实数，它在[0,1)范围内。
• seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
• shuffle(lst) 将序列的所有元素随机排序
• uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

• 三角函数

• acos(x) 返回x的反余弦弧度值。
• asin(x) 返回x的反正弦弧度值。
• atan(x) 返回x的反正切弧度值。
• atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
• cos(x) 返回x的弧度的余弦值。
• hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)。
• sin(x) 返回的x弧度的正弦值。
• tan(x) 返回x弧度的正切值。
• degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
• radians(x) 将角度转换为弧度

2.布尔值

只有True和False两个值，对应的整型数字为1和0，1代表True，0代表False。正好与shell的0和1相反
* 举例

>>> 1 > 2
False
>>> 2 > 1
True

3.字符串

• 字符串赋值变量

• 通常将字符串赋值给变量只需要将此字符串使用单引号或双引号括起来即可 如：name = abc,此时已经将字符串abc赋值给了变量name，
• 字符串拼接

>>> print("fu" + "zj")
fuzj
>>> print("fu","zj")
fu zj
>>> print("fu""zj")
fuzj

注意：字符串拼接＋号会重新在内存空间中开辟一块新的地址空间存放新的字符串；，号会中间自动加空格

• 字符串常见操作

• 移除空白／换行符 strip.()

>>> a = "   Hellow World    "
>>> a.lstrip()     ＃移除左边空格
'Hellow World    '   
>>> a.rstrip()    ＃移除右边空格
'   Hellow World' 
>>> a.strip()       ＃移除所有空格
'Hellow World'
>>> a = "   Hellow World    \n"      ＃移除换行符
>>> a.strip()
'Hellow World'
分割 split.()
>>> a = "1,2,3,4,5"     
>>> a.split(",")   #按逗号分割字符串，分割后的结果为列表
['1', '2', '3', '4', '5']
>>> a.split("3")
['1,2,', ',4,5']

• 长度 len.()

>>> a = "1,2,3,4,5"
>>> len(a)
9

• 索引

>>> a = "1,2,3,4,5"
>>> a[1]
','
>>> a[0]
'1'
>>> a[3]
','

• 切片

>>> a = "1,2,3,4,5"
>>> a[0:2]
'1,'
>>> a[0:4]
'1,2,'
>>> a[:4]
'1,2,'
>>> a[3:4]
','
>>> a[2:4]
'2,'

• 字符串格式化输出

• 方法

>>> name = "fuzj"
>>> print("Welcom  %s" % name)
Welcom  fuzj

• 字符串格式化符号

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

• format格式化输出

• 语法：它通过{}和:来代替% ,{}里可以是数字索引，可以是关键字参数，从0开始
• 示例：

>>> print("hi {0},i am {1},let us go to {2}".format('fuzj','jeck','Beijing'))
hi fuzj,i am jeck,let us go to Beijing
>>> print("hi {name},i am {name1},let us go to {addr}".format(name='fuzj',name1='jeck',addr='Beijing'))
hi fuzj,i am jeck,let us go to Beijing

• 其他常用函数

• string.replace(原字符串,新字符串) 替换string中字符串
• string.center(width,自定义字符串) 返回一个原字符串居中,并使用自定义字符串填充至长度 width 的新字符串
• string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
• string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
• string.isalnum() 检查字符串是否全部是字母或数字，可以同时出现字母和数字
• string.isalpha() 检查字符串是否只包含字母，
• string.isdigit() 检查字符串只包含数字
• string.lower() 转换 string 中所有大写字符为小写.
• string.upper() 转换 string 中的小写字母为大写

4.运算

• 算术运算符

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

• 比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

• 赋值运算符

运算符	描述	实例
=	简单的赋值运算符	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

• 逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔与	(a and b) 返回 20。
or	x or y	布尔或	(a or b) 返回 10。
not	not x	布尔非	not(a and b) 返回 False

• 成员元算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

• 身份运算符

运算符	描述	实例
is	is是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
is not	is not是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1

• 位运算符



• 优先级



* 练习

>>> 1 + 2    ＃相加
3
>>> 10 - 2    ＃相减
8
>>> 10 * 2     ＃相乘
20 
>>> 10 / 2     ＃相除
5.0
>>> 10 / 3      ＃相除，python3会保留小数点，python2只会取整数，需使用10.0 /3形式
3.3333333333333335
>>> 10 % 3     ＃取余数
1
>>> 10 // 3   ＃取商的整数部分
3
>>> "abc" == "abc"     ＃字符串相比较
True
>>> "abc" != "abc"
False
>>> "abc" <> "aasdbc"   ＃python3不支持，python2可以
  File "<stdin>", line 1
    "abc" <> "aasdbc"
           ^
SyntaxError: invalid syntax
>>> 1 > 2
False
>>> 1< 2
True
>>> 10 >= 2
True
>>> 10 <= 11
True
>>>

5.列表List

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现

• 定义列表

• 手动定义
  创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。注意字符串要使用引号

>>> list1 = ['fuzj','jeck','123']
>>> list2 = [1,2,3,4,5]
>>> list3 = ['h','s',1,2,3,4]

• 函数生成 list.()

>>> list("hollow")
['h', 'o', 'l', 'l', 'o', 'w']
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 列表操作

• 索引

列表使用下标来索引表中的值，索引从0开始。同时支持根据列表项来查找索引，涉及函数list.index()

>>> test = ["a","b","c","d","e"]
>>> test[0]    ＃0表示第一个
'a'
>>> test[1]
'b'
>>> test[5]     ＃超出下标范围将报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
 IndexError: list index out of range
 >>> test = ["a","b","c","d","e"]
>>> test.index("a")    #根据列表项来查找索引
0
>>> test.index("d")
3

• 切片
  切片就是使用一组索引来取出两个索引中间的所有值，切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。数是可选的，而冒号是必须的。切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束，第三个数（冒号之后）表示切片间隔数，即步长。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。注意，返回的序列从开始位置开始 ，刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。
  最后总结为，顾头不顾尾

>>> test = ["a","b","c","d","e","f","g"]
>>> test[0:5]      ＃取第一个到第四个中间所有值
['a', 'b', 'c', 'd', 'e']
>>> test[1:4]        ＃取第2个到第三个中间所有值
['b', 'c', 'd']
>>> test[1:-1]        ＃取第2个到倒数第二个中间所有值
['b', 'c', 'd', 'e', 'f']
>>> test[1:-2]         ＃取第二个到倒数第三个中间所有值
['b', 'c', 'd', 'e']
>>> test[1:]             ＃取第二个到最后中间所有值
['b', 'c', 'd', 'e', 'f', 'g']
>>> test[1::2]       ＃取第二个到最后中间所有值，并且中间每隔一个打印。这又称为步长
['b', 'd', 'f']

• 追加

此操作是针对列表的末尾进行添加新值，涉及的函数list.append()或list.extend()
append()是直接将括号里的对象加入到列表，extend.()一般用在列表中，将列表的值加入到list中，并且不去重

>>> test = ["a","b","c","d","e","f","g"]
>>> test.append("hhh")      ＃将hhh加入到test列表
>>> test
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'hhh']
>>> new = [1,2,3,4,5]      
>>> test.append(new)   ＃使用append将new列表加入到test列表，发现是将整个列表作为test一个列表项
>>> test
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'hhh', [1, 2, 3, 4, 5]]
>>> test.extend(new)  ＃使用extend讲new列表加入到test列表。发现是将new的列表项作为test的新的列表项
>>> test
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'hhh', [1, 2, 3, 4, 5], 1, 2, 3, 4, 5]

• 插入

此操作是在列表的任意位置插入新的列表项，涉及的函数 list.insert()

>>> test
['a', 'ddddd', 'b', 'ddddd', 'c']
>>> test = ["a","b","c"]
>>> test.insert(1,"ddddd")
>>> test
['a', 'ddddd', 'b', 'c']
>>> test.insert(-1,"ddddd")
>>> test
['a', 'ddddd', 'b', 'ddddd', 'c']

• 更新

此操作是根据索引来更新对应的列表项

>>> test
['a', 'ddddd', 'b', 'ddddd', 'c']
>>> test[4]="g"
>>> test
['a', 'ddddd', 'b', 'ddddd', 'g']

• 删除

此操作是直接删除列表项，涉及的函list.remove(),del，list.pop()
list.remove()每次只能删除一个列表项
del可以同时删除所有匹配的（通用函数）
list.pop() 每次删除最后一个列表项，并打印删除内容

>>> test = ["a","b","c","d","b","b","b","d","d","d"]
>>> test
['a', 'b', 'c', 'd', 'b', 'b', 'b', 'd', 'd', 'd']
>>> test.remove("d")
>>> test
['a', 'b', 'c', 'b', 'b', 'b', 'd', 'd', 'd']
>>> del test[0:3]
>>> test
['b', 'b', 'b', 'd', 'd', 'd']
>>> test.pop()
'd'
>>> test
['b', 'b', 'b', 'd', 'd']

• 循环

可使用for循环遍历列表，打印列表项

>>> for i in test:
        print(i)

    b
    b
    b
    d
    d

• 复制

列表的复制一般为浅复制，会在内存块中开辟新的空间，供新的列表使用，但是列表中如果某个项是一个列表或字典时，此时copy的只是一个链接，此链接还继续指向原来的地址块，下面脚本说明此问题

#!/usr/bin/env python
    # -*- coding: UTF-8 -*-
    #pyversion:python3.5
    #owner:fuzj

    import copy

    name = ['zhangsan','lisi',[1,3,4,5,6,9],2,9,0,9,7,8,8,9,4,3,2,6,7,8,9]
    name1 = name.copy()      ＃name1为name的浅copy
    name2 = name               ＃name2为name直接在内存块里链接
    name3 = copy.deepcopy(name)   ＃name3为name的深度copy

    name[0] = 'fuzj'       ＃修改name的列表项
    name[2][4] = 555555555555   ＃修改name列表项下的列表项

    print('name:',name)
    print('name1:',name1)
    print('name2:',name2)
    print('name3:',name3)

运行结果

name: ['fuzj', 'lisi', [1, 3, 4, 5, 555555555555, 9], 2, 9, 0, 9, 7, 8, 8, 9, 4, 3, 2, 6, 7, 8, 9]
name1: ['zhangsan', 'lisi', [1, 3, 4, 5, 555555555555, 9], 2, 9, 0, 9, 7, 8, 8, 9, 4, 3, 2, 6, 7, 8, 9]
name2: ['fuzj', 'lisi', [1, 3, 4, 5, 555555555555, 9], 2, 9, 0, 9, 7, 8, 8, 9, 4, 3, 2, 6, 7, 8, 9]
name3: ['zhangsan', 'lisi', [1, 3, 4, 5, 6, 9], 2, 9, 0, 9, 7, 8, 8, 9, 4, 3, 2, 6, 7, 8, 9]

发现，浅copy的由于内存地址块变了。所以即使是原来list列表项发生变化，但是自己不会变，但是列表项中的列表值变了。是因为他们还指向的是同一地址块。而深度copy是把列表项的列表的地址块也copy了。所以不变
PS：python3才支持list.copy()函数，pyhton2不支持

• 列表常用其他函数

• list.reverse() 反向列表中元素
• list.sort([func]) 对原列表进行排序
• list.count(obj) 统计列表项在列表中出现的次数
• len(list) 显示列表长度

6.元组tuple

元组同列表类似，但是元组的项不能改变，这个元组一旦定义好之后，就不能改变，元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

• 创建：

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

• 访问：

同list，根据下标索引来访问，也支持切片，分步

```
>>> test = (1,2,3,4,5,6)
>>> test[0]
    1
>>> test[3]
    4
>>> test[0:3]
    (1, 2, 3)

```

 

• 删除

使用del函数来删除
del 元组名

• 其他函数

• cmp(tuple1, tuple2) 比较两个元组元素
• len(tuple) 计算元组元素个数

7.字典dict

• 格式及创建

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

• 访问字典

访问字典的值，一般是根据key来索引value，也可以使用get()函数来获取

```
>>> Dict = {"a":1,"b":2,"c":3}
>>> Dict["a"]
1
>>> Dict["b"]
2
>>> Dict["d"]      ＃key不存在时将报错
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
KeyError: 'd'
>>> Dict.get("c")  ＃使用get函数获取的话，如果key不存在则返回空
 1
>>> Dict.get("er")

```

• 更新字典
  更新key值时，如果key存在则更新，不存在将作为新key放入字典

>>> Dict["c"] = 1
>>> Dict["d"] = 100
>>> Dict
{'c': 1, 'b': 2, 'd': 100, 'a': 1}

• 删除key
  使用del 函数删除

>>> Dict
{'c': 1, 'b': 2, 'd': 100, 'a': 1}
>>> del Dict["d"]
>>> Dict
{'c': 1, 'b': 2, 'a': 1}

• 其他常用函数

• dict.clear() 清空字典
• len(dict) 计算字典的长度
• dict.copy() 返回字典的浅复制
• dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
• dict.has_key(key)如果键在字典dict里返回true，否则返回false python3已经不支持，建议使用in
• dict.keys() 返回字典的所有key
• dict.update(dict2) 把dict2的k/v 更新到dict里
• dict.values() 返回字典所有values
• dict.items() 将字典的key／value 拼成元组，最后以列表形式返回总的key/values
• radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default