【python之旅】python的基础一

一、关于模块那些事

   python的强大之处在于他有着丰富且强大的标准库和第三方库，很对功能都有相应的python库支持

例如：

sys模块：

1 # Author :GU
2 import sys
3 print(sys.path) ###打印环境变量
4 print(sys.argv)   ###打印相对路径

 执行结果：

1 ['C:\\Users\\Administrator\\PycharmProjects\\s14\\day2', 'C:\\Users\\Administrator\\PycharmProjects\\s14', 'C:\\Python35\\python35.zip', 'C:\\Python35\\DLLs', 'C:\\Python35\\lib', 'C:\\Python35', 'C:\\Python35\\lib\\site-packages']
2 ###################
3 python sys1.py helo world
4 ['sys1.py', 'helo', 'world']   ####把执行脚本时传递的参数获取到了

 os模块：

 1 # Author :GU
 2 import os
 3 cmd_res = os.system("dir") ###执行命令不报存结果
   print(" >",cmd_res)    

 4 执行结果
 5 C:\Users\Administrator\PycharmProjects\s14\day2 ��Ŀ¼
 6 2016/08/01 ��һ  ���� 09:46    <DIR>          .
 7 2016/08/01 ��һ  ���� 09:46    <DIR>          ..
 8 2016/07/30 ����  ���� 12:49               137 login.py
 9 2016/07/30 ����  ���� 10:36    <DIR>          new_dir
10 2016/08/01 ��һ  ���� 09:46               134 os_tesy.py
     > 0   返回为0，则成功
11 因为字符集的问题所有乱码，属于正常
12 # Author :GU
13 import os
14 #cmd_res = os.system("dir")
15 cmd_res = os.popen("dir").read()  ###执行这个命令之后，结果存在内存中，通过read读取出来
16 #print("  >",cmd_res)
17 os.mkdir("new_dir")
18 创建一个文件夹以new_dir命名的

 二、什么是.pyc

    执行Python代码时，如果导入了其他的 .py 文件，那么，执行过程中会先自动生成一个与其同名的 .pyc 文件，第二次运行的时候程序会先找这个pyc的文件，该文件就是Python解释器编译之后产生的字节码。

    代码经过编译可以产生字节码；字节码通过反编译也可以得到代码。（任何字节码通过反编译都可以得到代码）

三、关于数据类型的那些事

　1、数字  

   int （整型）　　　

1 　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
2 　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
　long（长整型）python3变为整型
1 　　跟C语言不同，Python的长整数没有指定位宽，
2 　　即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
3 　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

   float（浮点型）

1 浮点数用来处理实数，即带有小数的数字。
2 浮点表示的形式是小数，但小数不一定都是浮点型
  3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
   complex（复数） 
1 　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
2 　　注：Python中存在小数字池：-5 ～ 257

　2、布尔值   

1 真或假
2 0或1
3 >>> a = 0
4 >>> if a :print("a")
5 ...
6 >>> a = 1
7 >>> if a :print("a")
8 ...
9 a
四、数据运算

算术运算：

操作符描述符例子
+ 加法 - 对操作符的两侧增加值 a + b = 30
- 减法 - 减去从左侧操作数右侧操作数 a - b = -10
* 乘法 - 相乘的运算符两侧的值 a * b = 200
/ 除 - 由右侧操作数除以左侧操作数 b / a = 2
% 模 - 由右侧操作数和余返回除以左侧操作数 b % a = 0
** 指数- 执行对操作指数（幂）的计算 a**b = 10 的幂 20
// 取整除 - 操作数的除法，其中结果是将小数点后的位数被除去的商。 9//2 =  4 而 9.0//2.0 = 4.0

比较运算：

运算符描述示例
== 检查，两个操作数的值是否相等，如果是则条件变为真。 (a == b) 不为 true.
!= 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 (a != b) 为 true.
<> 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 (a <> b) 为 true。这个类似于 != 运算符
> 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 (a > b) 不为 true.
< 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 (a < b) 为 true.
>= 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 (a >= b) 不为 true.
<= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 (a <= b) 为 true.

赋值运算：

运算符描述示例
= 简单的赋值运算符，赋值从右侧操作数左侧操作数 c = a + b将指定的值 a + b 到  c
+= 加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数 c += a 相当于 c = c + a
-= 减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数 c -= a 相当于 c = c - a
*= 乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数 c *= a 相当于 c = c * a
/= 除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数 c /= a 相当于= c / a
%= 模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数 c %= a is equivalent to c = c % a
**= 指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数 c **= a 相当于 c = c ** a
//= 地板除，并分配一个值，执行地板除对操作和赋值给左操作数 c //= a 相当于 c = c // a

位运算：

操作符描述示例
& 二进制和复制操作了一下，结果，如果它存在于两个操作数。 (a & b) = 12 即 0000 1100
| 二进制或复制操作了一个比特，如果它存在一个操作数中。 (a | b) = 61 即 0011 1101
^ 二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特。 (a ^ b) =  49 即  0011 0001
~ 二进制的补运算符是一元的，并有“翻转”位的效果。 (~a ) =  -61 即 1100 0011以2的补码形式由于带符号二进制数。
<< 二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。 a << 2 = 240 即 1111 0000
>> 二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。

a >> 2 = 15 即 0000 1111

 
 1 a = 60            # 60 = 0011 1100
 2 b = 13            # 13 = 0000 1101
 3 c = 0
 4   
 5 c = a & b;        # 12 = 0000 1100
 6 print "Line 1 - Value of c is ", c
 7   
 8 c = a | b;        # 61 = 0011 1101
 9 print "Line 2 - Value of c is ", c
10   
11 c = a ^ b;        # 49 = 0011 0001
12 print "Line 3 - Value of c is ", c
13   
14 c = ~a;           # -61 = 1100 0011
15 print "Line 4 - Value of c is ", c
16   
17 c = a << 2;       # 240 = 1111 0000
18 print "Line 5 - Value of c is ", c
19   
20 c = a >> 2;       # 15 = 0000 1111
21 print "Line 6 - Value of c is ", c

逻辑运算：

运算符描述示例
and 所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。 (a and b) 为 true.
or 所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。 (a or b) 为 true.
not 所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。

not(a and b) 为 false.

 

 1 例子：
 2 and运算，都为真时为真
 3 >>> 9 > 8 and 9 < 10
 4 True
 5 >>> 9 > 8 and 9 > 10
 6 False
 7  
 8 or运算，有一个为真的时候即可为真
 9 >>> 9 > 8 or 9 > 10
10 True
11 >>> 9 < 8 or 9 > 10
12 False
13 >>>
14  
15 not运算，假为真真为假
16 >>> not 6.2 <= 6
17 True
18 >>> not 6.2 >= 6
19 False
20 >>>

五、三元运算：

1 result = 值1 if 条件 else 值2

　　例子：

1 name = raw_input("please input your name: ")
2 if name = "tianshuai":
3     print "you are so shuai!!!"
4 else:
5     print "you are ok"

六、进制

  • 二进制，01
  • 八进制，01234567
  • 十进制，0123456789
  • 十六进制，0123456789ABCDEF

七、bytes类型

1 msg = "顾云"
2 print(msg)
3 print(msg.encode(encoding="utf-8"))
4 print(msg.encode(encoding="utf-8").decode(encoding="utf-8"))
5 
6 执行结果：
7 顾云
8 b'\xe9\xa1\xbe\xe4\xba\x91'
9 顾云

八、列表的操作

　　列表是我们最常用的数据类型，通过列表可以对数据实现最方便的存储、修改等操作

　　如何定义列表？

1 names = ["Zhangyang","Guyun","Xiangpeng","Xuliangchen"]

　　切片

 1 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
 2 print(names[0],names[2])
 3 执行结果：
 4 zhangyang xiangpeng
 5 ==============================================================
 6 # Author :GU
 7 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
 8 print(names[1:3])  ####切片
 9 执行结果：
10 ['guyun', 'xiangpeng']
11 =============================================================
12 取出最后一个值
13 # Author :GU
14 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
15 print(names[-1])
16 执行结果：
17 xuliangchen
18 =============================================================
19 取最后两个值
20 # Author :GU
21 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
22 print(names[-2:])
23 执行结果：
24 ['xiangpeng', 'xuliangchen']
25 =============================================================
26 从0取到3
27 # Author :GU
28 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
29 print(names[:3])
30 执行结果：
31 ['zhangyang', 'guyun', 'xiangpeng']

 　　追加：

 1 追加到末尾：
 2 # Author :GU
 3 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
 4 names.append("leihaidong")
 5 print(names)
 6 执行结果：
 7 ['zhangyang', 'guyun', 'xiangpeng', 'xuliangchen', 'leihaidong']
 8 =======================================================================
 9 追加到guyn的前面
10 # Author :GU
11 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
12 names.insert(1,"chenronghua")
13 print(names)
14 执行结果：
15 ['zhangyang', 'chenronghua', 'guyun', 'xiangpeng', 'xuliangchen']
16 =======================================================================
17 # Author :GU
18 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
19 names.insert(1,"chenronghua")
20 names.insert(3,"xinzhiyu")
21 print(names)
22 执行结果：
23 ['zhangyang', 'chenronghua', 'guyun', 'xinzhiyu', 'xiangpeng', 'xuliangchen']

　　修改：

1 将guyun改为xiedi
2 # Author :GU
3 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
4 names.insert(1,"chenronghua")
5 names.insert(3,"xinzhiyu")
6 names[2] = "xiedi"
7 print(names)
8 执行结果：
9 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng', 'xuliangchen']

　　删除：

 1 删除chenronghua
 2 方法一：
 3 # Author :GU
 4 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
 5 names.insert(1,"chenronghua")
 6 names.insert(3,"xinzhiyu")
 7 names[2] = "xiedi"
 8 names.remove("chenronghua")
 9 print(names)
10 执行结果：
11 ['zhangyang', 'xiedi', 'xinzhiyu', 'xiangpeng', 'xuliangchen']
12 方法二：
13 # Author :GU
14 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
15 names.insert(1,"chenronghua")
16 names.insert(3,"xinzhiyu")
17 names[2] = "xiedi"
18 del names[1]
19 print(names)
20 执行结果：
21 ['zhangyang', 'xiedi', 'xinzhiyu', 'xiangpeng', 'xuliangchen']
22 ==================================================
23 删除最后一个
24 # Author :GU
25 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
26 names.insert(1,"chenronghua")
27 names.insert(3,"xinzhiyu")
28 names[2] = "xiedi"
29 names.pop()  ##如果写上下标就可以指定删除
30 print(names)
31 执行结果：
32 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng']

　　获取下标：

 1 # Author :GU
 2 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
 3 names.insert(1,"chenronghua")
 4 names.insert(3,"xinzhiyu")
 5 names[2] = "xiedi"
 6 names.pop()
 7 print(names)
 8 print(names.index("xiedi"))
 9 执行结果：
10 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng']
11 2
12 =============================================
13 #取出xiedi
14 # Author :GU
15 names = ["zhangyang","guyun","xiangpeng","xuliangchen"]
16 names.insert(1,"chenronghua")
17 names.insert(3,"xinzhiyu")
18 names[2] = "xiedi"
19 names.pop()
20 print(names)
21 print(names.index("xiedi"))
22 print(names[names.index("xiedi")])
23 执行结果：
24 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng']
25 2
26 xiedi

 　　统计：

# Author :GU
names = ["zhangyang","guyun","xiangpeng","chenronghua","xuliangchen"]
names.insert(1,"chenronghua")
names.insert(3,"xinzhiyu")
names[2] = "xiedi"
print(names)
print(names.count("chenronghua"))
执行结果：
['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng', 'chenronghua', 'xuliangchen']
2

　　清除：

# Author :GU
names = ["zhangyang","guyun","xiangpeng","chenronghua","xuliangchen"]
names.insert(1,"chenronghua")
names.insert(3,"xinzhiyu")
names[2] = "xiedi"
names.clear()
print(names)
执行结果：
[]

　　反转：

 1 # Author :GU
 2 names = ["zhangyang","guyun","xiangpeng","chenronghua","xuliangchen"]
 3 names.insert(1,"chenronghua")
 4 names.insert(3,"xinzhiyu")
 5 names[2] = "xiedi"
 6 print(names)
 7 names.reverse()
 8 print(names)
 9 执行结果：
10 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng', 'chenronghua', 'xuliangchen']
11 ['xuliangchen', 'chenronghua', 'xiangpeng', 'xinzhiyu', 'xiedi', 'chenronghua', 'zhangyang']

　　排序：

 1 # Author :GU
 2 names = ["zhangyang","guyun","xiangpeng","chenronghua","xuliangchen"]
 3 names.insert(1,"chenronghua")
 4 names.insert(3,"xinzhiyu")
 5 names[2] = "xiedi"
 6 print(names)
 7 names.sort()
 8 print(names)
 9 执行结果：
10 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng', 'chenronghua', 'xuliangchen']
11 ['chenronghua', 'chenronghua', 'xiangpeng', 'xiedi', 'xinzhiyu', 'xuliangchen', 'zhangyang']

　　扩展：

 1 # Author :GU
 2 names = ["zhangyang","guyun","xiangpeng","chenronghua","xuliangchen"]
 3 names.insert(1,"chenronghua")
 4 names.insert(3,"xinzhiyu")
 5 names[2] = "xiedi"
 6 print(names)
 7 names2 = [1,2,3,4]
 8 names.extend(names2)
 9 print(names)
10 执行结果：
11 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng', 'chenronghua', 'xuliangchen']
12 ['zhangyang', 'chenronghua', 'xiedi', 'xinzhiyu', 'xiangpeng', 'chenronghua', 'xuliangchen', 1, 2, 3, 4]

　　拷贝：

# Author :GU
names = ["zhangyang","guyun","xiangpeng","chenronghua","xuliangchen"]
name2 = names.copy()
print(names)
print(name2)
names[3] ="向鹏"
print(names)
执行结果：
['zhangyang', 'guyun', 'xiangpeng', 'chenronghua', 'xuliangchen']
['zhangyang', 'guyun', 'xiangpeng', 'chenronghua', 'xuliangchen']
['zhangyang', 'guyun', 'xiangpeng', '向鹏', 'xuliangchen']
================================================

　　循环：

 1 # Author :GU
 2 names = ["zhangyang","guyun","xiangpeng",["alex","jack"],"chenronghua","xuliangchen"]
 3 for i in names:
 4     print(i)
 5 执行结果：
 6 zhangyang
 7 guyun
 8 xiangpeng
 9 ['alex', 'jack']
10 chenronghua
11 xuliangchen
12 =========================================

　　元组：

　　元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

1 names = ("alex","jack","eric")
　只有两个方法：1、count#统计 2、index#获取下

九、字符串的常用操作

　　首字母大写capitalize()

1 # Author :GU
2 name = "guyun"
3 print(name.capitalize())
4 执行结果：
5 Guyun

　　统计重复的字符count：

1 # Author :GU
2 name = "guyun"
3 print(name.count("u"))
4 执行结果：
5 2

　　center的用法：　　

　　一共打印50个字符，不够的用=补上字符放中间center的用法

1 # Author :GU
2 name = "guyun a "
3 print(name.center(50,"="))
4 执行结果
5 =====================guyun a =====================

 

　　以什么结尾endswith：

1 # Author :GU
2 name = "guyun"
3 print(name.endswith("un"))
4 执行结果：
5 True

　　找到索引：

1 # Author :GU
2 name = "guyun"
3 print(name.find("y"))
4 执行结果：
5 2

　　判断是否是纯英文字符：

1 # Author :GU
2 name = "guyun"
3 print(name.isalpha())
4 执行结果：
5 True

十、字典的操作

　　编写字典：

1 # Author :GU
2 info = {
3     'stu1101': "TengLan Wu",
4     'stu1102': "LongZe Luola",
5     'stu1103': "XiaoZe Maliya",
6 }

　　如果存在则修改，不存在则创建：

1 >>> info['stu1101'] = "武藤兰"
2 >>> info
3 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

　　查找：

1 # Author :GU
2 info = {
3     'stu1101': "TengLan Wu",
4     'stu1102': "LongZe Luola",
5     'stu1103': "XiaoZe Maliya",
6 }
7 print(info["stu1101"])
　执行结果:
　TengLan Wu
　>>> info.get("stu1102")  #获取
　'LongZe Luola'

　　删除：

 1 # Author :GU
 2 info = {
 3     'stu1101': "TengLan Wu",
 4     'stu1102': "LongZe Luola",
 5     'stu1103': "XiaoZe Maliya",
 6 }
 7 info.pop("stu1101")
 8 print(info)
 9 执行结果：
10 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}

　　多级字典嵌套及操作：

 1 av_catalog = {
 2     "欧美":{
 3         "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
 4         "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
 5         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
 6         "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
 7     },
 8     "日韩":{
 9         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
10     },
11     "大陆":{
12         "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
13     }
14 }
15 
16 av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
17 print(av_catalog["大陆"]["1024"])
18 #ouput 
19 ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

 

posted @ 2016-08-01 09:51  有位青年  阅读(306)  评论(0)  编辑  收藏  举报