python基础学习笔记

python

python运算符
 算术运算符(+ - * / % ** //

a = 20
b = 10
c = 0
c = a + b
print(c) # 30
c = a - b
print(c) #10
c = a / b
print(c) # 2.0
c = a * b
print(c) # 200
c = a // b
print(c) # 2
c = a % b
print(c) # 0

比较运算符
 比较对象相等 ==
 不相等 !=
 大于 >
 小于 <
 大于等于 >=
 大于等于 <=
赋值运算符
  = / += / -= /*= / /= / %= / *= / //=
位运算符
 #数字二进制计算
 与运算&
 或运算|
 异或运算^
 取反运算~
 左移运算<<
 右移运算>>
逻辑运算符
 and or not
成员运算符
 in /not in
身份运算符
 判断两个标识符是不是引用同一个对象
 is / is not
运算符优先级
 指数最高，取反~， / % // + - >> << & ^ | 比较运算符 赋值运算符 身份运算符 成员运算符 逻辑运算符

条件语句
 if语句的执行过程

两种形式

#第一种
if 判断语句：
	执行语句
else：
	执行语句

#第二种 多个判断语句使用elif
if 判断语句1:
	执行语句1
elif 判断语句2：
	执行语句2
elif 判断语句3：
	执行语句3
else：
	执行语句4

循环语句
 循环语句执行过程

python 提供两种循环for和while循环
while循环：在给定的判断条件为true时执行循环否则退出循环体

# while 判断条件(condition):
		执行语句(statements)
x = 10
number = []
while x > 0:
    number.append(x)
    x -= 1
print(number)
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

for循环：重复执行语句,遍历任何序列的项目

# for iterating_var in sequence:
		statements(s)
import numpy as np
for x in np.arange(0,10):
    print(x,end =',')
# 0,1,2,3,4,5,6,7,8,9,

循环控制语句
  break语句：在语句执行过程中终止循环，并且跳出整个循环
  continue语句：在语句执行过程中终止当前循环，跳出该次循环，执行下一次循环
  pass语句：pass语句是空语句，为了保持结构的完整性
循环嵌套

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

while expression:
   while expression:
      statement(s)
   statement(s)

数据类型

  数字(numbers),字符串(String),列表(List),元组(Tuple),字典(Dictionary)

 数字类型：整型，浮点型，长整型，复数类型

python随机数函数
 chioce(seq):从序列的元素中随机挑选一个元素

np.random.choice(np.arange(10))

 randrange([start,]stop[,step]):指定递增基数集合中的一个随机数，基数默认值为1

random.randrange(1000)
#834

 random():随机生成下一个实数，它在[0,1)范围内

random.random() 
#0.624330298064482

 shuffle(lst):将序列的所有元素随机排列

list = [1,2,3,4,5]
random.shuffle(list)
print(list)
# [2, 1, 5, 4, 3]

 uniform() 方法将随机生成下一个实数，它在 [x, y] 范围内。

random.uniform(1,3)
# 1.6680480175356636

python字符串
 Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
 Python 访问子字符串，可以使用方括号来截取字符串,需要使用特殊字符时，使用反斜杠 \ 转义字符
 格式化字符串

print("my name is %s and weight is %d kg" %('zara',21))
# %c 格式化字符及ascii码 %o格式化无符号八进制 %x 无符号16进制
  %s 格式化字符串  %d 格式化整数  %u 格式化无符号整数
  %X 无符号16进制 %f浮点数 %e 科学计数法 %

pthon内建函数
 string.capitalize():把字符串的第一个字符大写

"abc".capitalize()
# Abc

  string.center(width):返回一个原字符串居中，并使用空格填充至长度width的新字符串

"ABC".center(10)
# '   ABC    '

  string.count(str,beg=0,end = len(str)):返回str在string中出现的次数，如果beg或者end指定则返回范围内str出现的次数

"asdasdsdfa".count('a',1,10)
# 2

string.decode(encoding=‘UTF-8’,errors=‘strict’):以encoding指定的编码格式解码string，如果出错默认报一个valueError的异常，除非errors指定的时ignore或者replace

import base64
str = "this is UTF-8"
str = str.encode('UTF-8','strict')
print(str)
str = base64.b64encode(str)
print(str)
str = base64.b64decode(str)
print(str)
# b'this is UTF-8'
# b'dGhpcyBpcyBVVEYtOA=='
# b'this is UTF-8'

string.encode(encoding=‘UTF-8’,errors=‘strict’):以encoding指定的编码格式编码string，如果出错默认报一个valueError的异常，除非errors指定的时ignore或者replace

string.endswith(obj,beg=0,end=len(string))
检查字符串是否以obj结束，如果beg或者end指定则返回范围内是否以obj结束，是返回true，否返回false

string.expandtabs(tabsize=8)把字符串string中的tab符号转为空格，tab符号默认的空格为8个

"123\t456".expandtabs()
#'123     456'

string.find(str,beg=0,end=len(string)):检测str是否包含在string中，返回开始的索引值，否则返回-1

"1232341445".find('1')
# 0

string.format():格式化字符串

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
# 网站名：菜鸟教程, 地址 www.runoob.com

string.isalnum():如果string至少有一个字符并且所有字符都是字母或数字则返回true 否则返回false

列表List
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
列表的值可以更改
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
列表函数&方法

#函数
#operator.eq(list1,list2):比较相等
#len(list):列表元素个数
#max(list):列表最大值
#min(list):列表最小值
#list(seq):将元组转为列表

#方法
#list.append(obj):在列表末尾添加新的对象
#list.count(obj):统计某个元素在列表中出现的次数
#list.extend(seq):在列表末尾一次性追加另一个序列的多个值
#list.index(obj):在列表中找出某个值第一个匹配的索引位置
#list.insert(index,obj):在列表的index出插入obj
#list.remove(obj):移除列表obj的第一个匹配项
#list.pop(index=-1):移除列表的一个元素,默认最后一个元素，并且返回该元素的值。
#list.reverse():反向列表中的元素
#list.sort(cmp=None，key=None，reverse=False):列表排序

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

tup1 = (12, 34.56)
# 以下修改元组元素操作是非法的。
# tup1[0] = 100

字典Dictionary
字典是一种可变容器模型，且可储存任意类型对象
字典特性
1.键是唯一的，如果重复，最后一个键值会替换前面的，值不需要唯一。
2.键是不可变的所以用数字u，字符串或元组充当，列表不行

#字典样板
d = {key1 : value1, key2 : value2 }
>>> dict = {'a': 1, 'b': 2, 'b': '3'}
>>> dict['b']
'3'
>>> dict
{'a': 1, 'b': '3'}

字典内置方法

#dict.clear():删除字典内所有元素
#dict.copy():返回一个字典的浅拷贝
#dict.fromkeys(seq[.val]):创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值。
#dict.get(key,default=None):返回指定键的值，如果值不在字典中返回默认值
#dict.has_key(key):如果键在字典dict里返回true，否则返回false
#dict.items():以列表返回可遍历的元组数组
#dict.keys():以列表返回一个字典所有的键
#dict.update(dict2):将字典dict2的键值对更新到dict里
#dict.values():以列表返回字典中的所有值
#dict.pop(key[,default]):删除字典给定键key所对应的值，返回值为被删除的值。key必须给出
#dict.popiterm():删除字典中最后一对键值对

直接赋值：其实就是对象的引用（别名）。
浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

 
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
 
b = a                       #赋值，传对象的引用
c = copy.copy(a)            #对象拷贝，浅拷贝
d = copy.deepcopy(a)        #对象拷贝，深拷贝
 
a.append(5)                 #修改对象a
a[4].append('c')            #修改对象a中的['a', 'b']数组对象
 
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )

#('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
#('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
#('c = ', [1, 2, 3, 4, ['a', 'b', 'c']])
#('d = ', [1, 2, 3, 4, ['a', 'b']])