Python第一二节

发表于   |   更新于 | 分类于 | 阅读次数
字数统计: 3.8k | 阅读时长 ≈ 18

Python 基础入门：

调试方法见此链接.

第一节课 入门基础

首先有爬虫和性能提升的测试. 本节课： python 应用场景丰富：接口测试、UI自动化、数据分析处理、机器学习与大数据分析，语法简单，技术成熟、大量的参考/例子代码. 你的生产力以及——解决问题的能力 是程序员必备的技能！生产力一定要牛批！ 效率提升： json——基于java的虚拟机去提升效率 或者用c++/c的底层在python中运用着去解决可能存在的慢的问题。 源的问题： pip install pandas //但是国外的源是需要翻墙的 pip list // 列举出已经安装上的包 pip -verbose install pandas //来查看自己安装这个包失败的原因/ 防火墙解决：——利用指定豆瓣的源 pip install -i —trusted-host http://pypi.douban.com/simple/ pandas 坑： pytz文件的不支持安装—— 去pandas官网上下载安装 建议: 在敲打代码的时候，语法细节不一定记得清楚。对于常用的语法最好在笔记本中记一下，用到了 复制粘贴一把。 推荐网站： https://lintcode.com/problem/ https://github.com/yingl/julyedu https://zhuanlan.zhihu.com/pythoner https://zhuanlan.zhihu.com/auxten https://zhuanlan.zhihu.com/zimei

语法相关——正式进入

常量
True
False
None
对象和容器
class
import
from
del
•判断
•if
•elif
•else
•is
•in
•assert
•循环
•for
•while
•continue //跳出当前循环
•break
•pass //什么都不做——因为缩进很是严格，pass 做一个填充、帮助编辑器、消除语义上的歧义.
•异常
•raise
•try
•except
•finally
•as
•算术运算
•+-/
•%
•*
•//
•比较运算
•>, >=
•<, <=
•==
•!=
-print(100 2) //10000 幂指数
-print(23 // 4) //只保留整数部分
•逻辑运算
•and
•or
•not
•位运算
•>>
•<<
•&
•|
•^
-print(not(c_1 == c_2)) #进行表示 异或的运算.

# -- coding: utf-8 --
# coding: utf-8

3.x不用担心上方 上方是进行 中文支持的操作添加.

c_1 = True
c_2 = False
print(not(c_1 == c_2))
print(16 << 2)
print(30 << 3)
print(70 >> 1)
print(100 >>3)

位运算好处 ， 快速点

def is_pow2(n):
return (n & (n-1)) == 0
print(is_pow2(16))
print(is_pow2(7))
print(0b1101 & 0b1011) #0b1001 9
print(0b1101 | 0b1011) #0b1111 15
print(0b1011 ^ 0b1011) #进行异或运算 0

单行注释

“””
第一行
第二行
注意这里 单双引号都是可以的!
“””

下面进行 换行和不换行

str = “abcd” \
“efgh”
print(str)
str = “abcd\\nefgh”
print(str)
str = “””abcd
efgh”””
print(str)

对于转义字符

print(“abcd’123’efgh”)
print(‘abcd”123”efgh’)
print(“abcd\\’123\\’efgh”)
print(“你们好！”)

区别：

1 3.x必须要加上()

2 3.xUnicode编码

3 除法运算，自动出现小数输出的结果

print(1/3)

4 异常：3.x只能抛出继承自BaseException的异常

5 range为实现惰性求值——了即只是你用到了这个数才给你分配这个数！现在rangee可以了 xrange取消这一个

for i in range(5): print(i)
x = [1,2,3,4,5]
print(type(x))
y = range(5)
print(type(y))

6 二进制和八进制 3.x必须强制携程0b1001和0o7236

7 不等式3.x 取消了 <> 表示的不等于 只有 != 了.

8 表达式:3.x 必须使用repr函数

9 多个模块改名:Queue->queue,repr->reprlib…

数据类型方面:

1 3.x取消了Long，统一为int

2 新增bytes类型，并可与string相互转换

3 dict的keys/items/values方法返回迭代器,iterkeys函数被废弃,has_key 被in取代.

2个字节表示 16位的整数， 4个字节表示32位的整数

print((1024).to_bytes(4, byteorder = “big”, signed = True)) #显示正常顺序的 16进制
print((1024).to_bytes(4, byteorder = “little”, signed = False)) #显示反向的 16进制表示
print((-1024).to_bytes(4, byteorder = “little”, signed = True)) #显示起始位为最小位

注意 前方有坑

print((3124).to_bytes(2, byteorder = “big”)) #本来应该是 0x0c34 但是输出\\x0c4

                                #因为输出16进制 34时发现 asicall码是可打印字符4
                                #所以在出现灵异的事情的时候注意从asicall等本质上理解!

print(“%x” % 3124)
print(“%d” % 0x0c34)

输出：

True
64
240
35
12
True
False
9
15
abcdefgh
abcd
efgh
abcd
efgh
abcd’123’efgh
abcd”123”efgh
abcd’123’efgh
你们好！
0.3333333333333333
1
2
3
4


b’\\x00\\x00\\x04\\x00’
b’\\x00\\x04\\x00\\x00’
b’\\x00\\xfc\\xff\\xff’
b’\\x0c4’
c34
3124

第二节：

  • 变量和类型
  • 常见字符串处理
  • 条件判断
  • 循环控制
  • 函数

_•基本变量类型_
•整数
•浮点数
•字符串
•布尔值
•空值
•函数
•模块
•类型
•自定义类型
---
_变量定义_ —— 在堆上分配相应的内存. 所以x=100 x=123.45 python可以进行数值类型的自由切换了！
•变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
•基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
•变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。（弱类型）
_变量赋值_
•每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。（重要！！！）
•等号（=）用来给变量赋值，等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
带有垃圾回收的语言——java所有的变量都是分配在堆上的，所以需要进行内存的回收
堆：随分配随着创建，堆上全局的不清理
栈：所有函数 是压入堆栈进行——所以 函数结束就会被清理干净了！
---
*_常见字符串处理_：
•去除空格及特殊符号：strip, lstrip, rstrip
•复制字符串：str1 = str2
•连接字符串
•str2 += str1
•new_str = str2 + str1
•查找字符串：pos = str1.index(str2)
•比较字符串：cmp(str1, str2) //python3当中被移除了，所以直接 == > < 进行直接的比较即可！
•字符串长度：len(str)
•大小写转换
•u_str = str.upper()
•l_str = str.lower()
注意：

空字符串(相当于false) 与 none字符串的区别：

s3 = ‘’
if s3 is None:
print(“s3 is none”)
elif not s3:
print(“Empty!”)
s4 = None;
if s4 is None:
print(“s3 is none”)
elif not s4:
print(“Empty!”)
•首字母大写：str.capitalize(); string.capword(str)

大小写转换：

s1=’abc’
print(s1.upper())
print(s1.upper().lower())
print(s1.capitalize()) //只是第一个字符大写
•分割与合并字符串：split, splitlines, join //重要！
# 分割和连接
s = ‘abc,def,ghi’
print(s.split(‘,’)) //返回[‘abc’,’def’,’ghi’]
s = ‘123\\n456\\n789’
numbers = s.splitlines() //按照行进行分割！
print(numbers)
print(‘-‘.join(numbers)) //abc-def-ghi 可以把结果进行合并回去！
_—-What’s More:_
•类型转换：int, float转换
# 数字到字符串
print(str(5))
print(str(5.)) #5.0
print(str(-5.23))

字符转换成数字

print(int(‘1234’))
print(float(‘-23.456’))
•格式化字符串
# 格式化字符串
print(‘Hello %s!’ % ‘world’)
print(‘%d-%.2f-%s’ % (4, -2.3, ‘hello’))
注意：
1:%6.2f
6表示数据表示至少6位,后面的.2表示小数点后保留两位
比如2342.123415用这个表示的话，结果就是2342.12
如果不足六位就会在前面补空格
超过六位的话正常显示
代码例子：
int main()
{
float a=3425.1234;
printf(“%6.2f”,a);
return 0;
}
结果就是3425.12
如果a=5.1234
那结果就是： 5.12,前面有3个空格
如果a=234525.123
则结果过就是234525.12
2:转换 python不会自动补全
print(int(‘123.45’)) #错误 因为自己字符要自己格式化成123 python不会给我们浮点数转换成整数
print(float(‘123’)) #输出： 123.0
print(int(‘110111’,2)) #55 2进制转换为 10进制 ，x进制转换为10进制！
_—-常用的判断_
# 常用判断
s = ‘abcdefg’
print(s.startswith(‘abc’))
print(s.endswith(‘efg’))
print(‘abcd1234’.isalnum()) #正常的字符
print(‘\\tabcd1234’.isalnum()) #False 非正常的
print(‘abcd’.isalpha()) #纯字母
print(‘12345’.isdigit()) #纯数字
print(‘ ‘.isspace()) #是不是空格
print(‘acb125’.islower()) #是不是大写
print(‘A1B2C’.isupper())
print(‘Hello world!’.istitle()) #首字母是否大写 False

要想修改字符串：

s = ‘asdaf’
s = list(s)
print(s)

_—-条件判断：_
if xx:
elif xx:
else:
s4 = None;
if s4 is None: #等价于 if not s4:
print(“s3 is none”)
elif not s4:
print(“Empty!”)
•真值判断
•if x == True:
•if x:
•if not x:
•空值判断
•if x is None:
•if not x:
‘’ == False
•比较
•if a == b:
•if a > b:
•…
# for循环 s = 0
for i in range(0, 101): #for i in 容器 range(start , end, step)
s += i
print(s)
# while循环
s = 0
i = 0
while i <= 100:
s += i
i += 1
print(s)
# continue/pass/break
for i in range(0, 100, 1):
if i < 10:
pass
elif i < 30:
continue
elif i < 35:
print(i)
else:
break

只打印了 30 31 32 33 34

注意： python当中是没有 switch case的！

_•函数定义格式_ #可以返回一个 (1,2) 元组
def func_name(arg_1, arg_2):
print(arg_1, arg_2);
return arg_1,arg_2
r = func_name(1, 2)
print(type(r),” “,r)
•默认参数
•可变参数：args，自动组装成tuple
def func(x, y = 100):
return x+y
print(func(y = 300,x = 200)) //python有自己的特性，直接在参数指定是哪个。
//这样就没有 特定的次序了！
•关键字参数：args，自动组装成dict
•命名关键字参数
# 函数定义和默认参数
def func(x, y = 500):
print(x, y)
func(150)
func(100, 200)
func(y = 300, x = 100)

可变参数 ！必须在最后!

def func(name, *numbers):
print(type(numbers)) #(1, 2, 3, 4, ‘abc’)

                      #tuple - 元组 <=> 只读数组
print(numbers)
print(numbers\[0\])
return 'Done'

func(‘Tom’, 1, 2, 3, 4, ‘abc’)

#注意 1.即可在python这些个容器中，开始不用考虑元素类型！  只是在后面计算时考虑类型进行计算#
    #2\. (1， 2) 在这里没有参数，所以不方便进行引用，所以考虑到用dic 字典类型

# 关键字参数
def func(name, **kvs): # ** means key/value
print(name)
print(kvs)
func(‘Jack’, china = ‘Beijing’, uk = ‘London’)

#output is as list：
Jack
{'china': 'BeiJing', 'uk': 'London'}

# 命名关键字参数
def func(, china, uk): # 用于和普通参数做分割，args一样效果
print(china, uk)
func(china = ‘Beijing’, uk = ‘London’) # 必须传入参数名
# 复杂情况
def func(a, b, c = 0, \args, **kvs):
print(a, b, c, args, kvs)
func(1, 2)
func(1, 2, 3)
func(1, 2, 3, ‘a’, ‘b’)
func(1, 2, 3, ‘a’, ‘b’, china = ‘Beijing’, uk = ‘London’)
func(1, 2, 3, (‘a’, ‘b’), *{‘china’:’Beijing’, ‘uk’:’London’})

 #output：
 1 2 0
 ()
 {}
 1 2 3
 ()
 {}
 1 2 3
 ('a', 'b')
 {}
 1 2 3
 ('a', 'b')
 {'china': 'Beijing', 'uk': 'London'}
 1 2 3
 ('a', 'b')
 {'china': 'Beijing', 'uk': 'London'}

# 递归的经典例子！
def fib(n):
if n < 1:
raise ValueError
elif (n == 1) or (n == 2):
return 1
else:
return fib(n - 1) + fib(n - 2)
print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(6))
# hanoi塔问题：
“””What’s More!”””
“””
def move(n,source,target,helper):
if n == 1:
print (source + ‘ -> ‘ + target)
else:
move(n-1, source ,helper, target)
print (source + ‘ -> ‘ + target)
move(n-1, helper, target, source)
move(4, ‘A’, ‘B’, ‘C’)
‘’’
A -> C: [2, 3, 4], [], [1]
A -> B: [3, 4], [2], [1]
C -> B: [3, 4], [1, 2]
A -> C: [4], [1, 2], [3]
B -> A: [1, 4], [2], [3]
B -> C: [1, 4], [], [2, 3]
A -> C: [4], [], [1, 2, 3]
A -> B: [], [4], [1, 2, 3]
C -> B: [], [1, 4], [2, 3]
C -> A: [2], [1, 4], [3]
B -> A: [1, 2], [4], [3]
C -> B: [1, 2], [3, 4], []
A -> C: [2], [3, 4], [1]
A -> B: [], [2, 3, 4], [1]
C -> B: [], [1, 2, 3, 4], []
‘’’
“””
# 注意 python中 函数可以作为参数的！
def
_•函数调用_
•函数名(参数名)
•模块名.函数名(参数名)
•带参数名调用
_•什么是递归？_

python 中所有的对象都是 继承自object的类，都有自己的方法

print(type(123))
print(type(123.))
print(type(123.45))
print(type(“str”))

开始容器的介绍

print(“\\n关于容器”)
print(type([1, 2, 3, ‘a’,’b’]))
print(type((1, 2, 3, ‘a’,’b’)))
print(type(set([1, 2, 3, ‘a’, ‘b’])))
print(type({1: 2, 3: ‘a’,4:’b’}))

函数也是个对象

def function(a ,b,c):
print(a , b, c)
print(type(function))
import string
print(type(string))

定义类

class MyClass(object):
pass
print(type(MyClass))
myClass = MyClass();
print(type(myClass));

python 所有都是对象！

python 没有自己的变量类型

try:
print(x)
except NameError:
print(“NameError!”)
print(“常见字符串的处理：”)

python 当中字符串不能被修改

s = “abc”

s[0] = x 错误

去除空格：

s = “ addas fsad “
print(s.strip())
print(s.lstrip())
print(s.rstrip())

链接字符串

s1 = ‘abc’
s2 = ‘def’
print(s1+ ‘\\n’ +s2)

大小写

print(s1.upper())
print(s1.upper().lower())
print(s1.capitalize())

空字符串(相当于false) 与 none字符串的区别：

s3 = ‘’
if s3 is None:
print(“s3 is none”)
elif not s3:
print(“Empty!”)
s4 = None;
if s4 is None:
print(“s3 is none”)
elif not s4:
print(“Empty!”)
print(len(‘’))

分割与链接

s = ‘abc,def,ghi’
splitted = s.split(‘,’)
print(type(splitted))
print(splitted)
# 数字到字符串
print(str(5))
print(str(5.)) #5.0
print(str(-5.23))

字符转换成数字

print(int(‘1234’))
print(float(‘-23.456’))
s = ‘asdaf’
s = list(s)
print(s)

关于 for循环

count = 0;
for i in range(0, 101):
count += i;
print(“count = “,count,”哈哈！”)

测试

for j in range(0, 10):
print(“当前测试的j: “,j);

测试 index

ss=’abcd’
dd=’efghabcd’
position = dd.index(ss)
print(“当前位置为：”,position)
print(‘Hello %s!’ % ‘world’)
print(‘%d-%.2f-%s’ % (4, -2.3, ‘hello’))
print(“%1.2f-%s” % (-22.345,’你好!’))

作业：

print(‘打印10000以内的所有素数’)

第二小节：

def func_name(arg_1, arg_2):
print(arg_1, arg_2);
return arg_1,arg_2
r = func_name(1, 2)
print(type(r),” “,r)

可变参数 ！必须在最后!

def func(name, *numbers):
print(type(numbers)) #(1, 2, 3, 4, ‘abc’)

                      #tuple - 远足 <=> 只读数组
print(numbers)
print(numbers\[0\])
return 'Done'

func(‘Tom’, 1, 2, 3, 4, ‘abc’)

字典类型 ** 意味着 key/value

def funcc(name, **kvs):
print(name)
print(kvs)
funcc(‘Jack’, china = ‘BeiJing’, uk = ‘London’)

有关于一些 复杂情况

def func(a, b ,c = 0, *args, **kvs):
print(a, b, c)
print(args)
print(kvs)
func(1, 2)
func(1, 2, 3)
func(1, 2, 3, ‘a’, ‘b’)
func(1, 2, 3, ‘a’, ‘b’, china = ‘Beijing’, uk = ‘London’)
func(1, 2, 3, (‘a’, ‘b’), *{‘china’:’Beijing’, ‘uk’:’London’})

有关于递归

def my_sum(i):
if i < 0:
raise ValueError
elif i <= 1:
return i
else:
return i + my_sum(i-1)
print(my_sum(1))
print(my_sum(2))
print(my_sum(3))
print(my_sum(100))

0 0 1 1

f(n) = f(n-1) + f(n-2)

def fib(n):
if( n < 1 ):
raise ValueError
elif( n<= 2):
return 1
else:
return fib(n-1) + fib(n - 2)
print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(10)) #时间的 花费太长了.

hanoi 问题

def hanoi(n, source, target, helper):
if n == 1:
print(source ,’ -> ‘, target)
else:
hanoi(n-1, source, helper, target)
print(source ,’ -> ‘, target)
hanoi(n-1, helper, target, source)
hanoi(4, ‘A’, ‘B’, ‘C’)

函数可以作为参数 -- 实现冒泡排序

def cmp(x, y , cp = None):
if not cp:
if x > y:
return 1
elif x < y:
return -1
else:
return 0
else:
return cp(x, y)

全局 和 局部是隔离的不能用！

def swap(x, y):
temp = x;
x = y;
y = temp;
def my_BubbleSort( x ):
temp = 0;
for i in range(0, len(x)-1, 1):
for j in range(0, len(x)-i-1, 1):
if x[j] > x[j+1]:
x[j],x[j+1] = x[j+1],x[j]
“””temp = x[j];
x[j] = x[j+1];
x[j+1] = temp;”””
print(x)
x = [ 15, 225, 34, 42, 52, 6, 7856, 865, 954, 10]
my_BubbleSort(x);

python 实现打印10000以内的所有素数

from math import sqrt
def primeNumber( n ):
x = []
for i in range(2, n):
flag = True;
for j in range(2, int(sqrt(i))+1):
if 0 == i%j:
flag = False
break
if True == flag:
print(i ,” “)
x.append(i)
return x
x = primeNumber(100)
print(x)
“””What’s More!”””
“””
def move(n,source,target,helper):
if n == 1:
print (source + ‘ -> ‘ + target)
else:
move(n-1, source ,helper, target)
print (source + ‘ -> ‘ + target)
move(n-1, helper, target, source)
move(4, ‘A’, ‘B’, ‘C’)
‘’’
A -> C: [2, 3, 4], [], [1]
A -> B: [3, 4], [2], [1]
C -> B: [3, 4], [1, 2]
A -> C: [4], [1, 2], [3]
B -> A: [1, 4], [2], [3]
B -> C: [1, 4], [], [2, 3]
A -> C: [4], [], [1, 2, 3]
A -> B: [], [4], [1, 2, 3]
C -> B: [], [1, 4], [2, 3]
C -> A: [2], [1, 4], [3]
B -> A: [1, 2], [4], [3]
C -> B: [1, 2], [3, 4], []
A -> C: [2], [3, 4], [1]
A -> B: [], [2, 3, 4], [1]
C -> B: [], [1, 2, 3, 4], []
‘’’
“””

(っ•̀ω•́)っ✎⁾⁾ 坚持技术学习、内容输出与分享，您的支持将鼓励我继续创作！(*/ω＼*)
( • ̀ω•́ )✧如有疑问或需要技术讨论，请留言或发邮件到 aclearzhang@qq.com.(*･ω< ) 
  • 本文作者：： AClearZhang
  • 本文链接：： 1249.html
  • 版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！