Python基础学习

Posted 2020-12-29 <?ph7?>

安装完Python并且调试成功第一个Hello word，下面通过廖雪峰网站开始学习python基础。学习网址：https://www.liaoxuefeng.com

一、格式化输出

　　格式化输出就相一个占位符一样在一个字符串之中，最后通过可变的参数替换占位符。最终输出结果；Python中，采用的格式化方式和C语言是一样的都是通过 % 实现；

　　常用的占位符有：

　　

 　　案例：

print(\'这是整数%2d, 这个你知道吗%02d\' %(1, 2))
print(\'这是整数%d, 这个你知道吗%d\' %(1, 2))
print(\'这是整数%d, 这个你知道吗%d\' %(100, 200))

　　输出结果：

这是整数 1, 这个你知道吗02
这是整数1, 这个你知道吗2
这是整数100, 这个你知道吗200

　　分析：以上这些是格式化输出整数，%2d  代表的是占2位输出的坑，所以在输出结果可以看出第一个输出前面是一个空，另外 %02d  代表的是两位输出，用0补给占位，即可得到02的输出。

print(\'%.2f\' % 3.1415926)

　　输出：3.14 

　　分析：浮点数保留两位小数的写法

　　如果不确定用那一个种格式化输出，记住%s 它永远起作用，它会把任何数据类型转换为字符串。

print(\'Age: %s. Gender: %s\' % (25, True))

　　输出：Age: 25. Gender: True

　　format（） 也是一种格式化输出，它会将传入的参数依次嗲换字符串内的占位符{0}  {1}  {2} ...　　

print(\'这是一个坑:{0}, 这是浮点数坑:{1:.1f}%, 这是其他的坑:{2}\'.format(\'我是坑\', 17.125, 100))

　　输出：这是一个坑:我是坑, 这是浮点数坑:17.1%, 这是其他的坑:100

 

二、使用list  和 tuple　　

 　　List 是一种有序集合，可以添加、删除其中的元素。　　 

#LIST学习
#创建一个list
listInfo = [\'aaa\', \'bbb\', \'ccc\'];
print( listInfo )

#计算list的长度 len()
print( len( listInfo ) )

#用索引访问list中的元素
print( listInfo[2] )

#通过负数倒着取元素
print( listInfo[-1] )

#list是一个可变的有序表
#往list里面追加元素 append()
listInfo.append(\'ddd\')
print( listInfo )

#也可以将插入的元素指定到指定的位置 insert()
listInfo.insert(2, \'cici\')
print( listInfo )

#删除list末尾的元素 pop(i) i是可变的位
listInfo.pop()
print( listInfo )

#把某个元素替换成别的元素
listInfo[2] = \'replace\'
print( listInfo )

#list的元素类型可以不同 True 区分大小写
setList = [\'aaa\', 111,  True]
print( setList )

#list元素也可以是另外一个元素
newList = [\'java\', \'php\', setList ]
print( newList )

#拿取多维list中的元素
print( newList[2][1] )

　　输出结果如下：　　

[\'aaa\', \'bbb\', \'ccc\']
3
ccc
ccc
[\'aaa\', \'bbb\', \'ccc\', \'ddd\']
[\'aaa\', \'bbb\', \'cici\', \'ccc\', \'ddd\']
[\'aaa\', \'bbb\', \'cici\', \'ccc\']
[\'aaa\', \'bbb\', \'replace\', \'ccc\']
[\'aaa\', 111, True]
[\'java\', \'php\', [\'aaa\', 111, True]]
111

　　tuple 另外一种列表叫元组：tuple. tuple和list 比较相似，但是tuple 一旦初始化就不能修改

　　　　   tuple 并没有 append()   insert() 方法，因为它不可变。只能通过键位获取。 相对list 来说比较安全。特别注意的是在使用tuple的时候，tuple的元素就必须确定下来。

#tuple
tupleInfo = ( 1, 2 )
print( tupleInfo )

　　输出：(1, 2)

#定义一个空的tuple
tupleInfo = ()
print( tupleInfo )

　　输出：（）

#定义一个只有1个元素的tuple
tupleInfo = (1111)
print( tupleInfo )

　　输出：1111

　　说明：如果下面这样定义才是真正的一个tuple,表示只有一个元素的tuple 

tupleInfo = (1111, )
print( tupleInfo )

　　输出：(1111,)

　　下面看这个案例，间接性的通过list去改变tuple 其实，变的是可变的list 而 tuple 并没有变，只是间接性的像变了一样。

mylist = [\'php\', \'java\', \'c#\']
tupleInfo = (111,222,333, mylist )
print( tupleInfo )
tupleInfo[3][1] = \'mysql\'
print( tupleInfo )

　　输出：(111, 222, 333, [\'php\', \'java\', \'c#\'])    （111, 222, 333, [\'php\', \'mysql\', \'c#\'])

 

三、条件判断 循环

x = 70;
if x <60 :
    print( \'这个分数小于60了\' )
elif x >= 60:
    print( \'这个分数大于60了\' )
else:
    print(\'优秀了呢\')

　　python 需要分为两种，第一种是 for ... in  的方式 将 list 货 tuple 总的数据列出来； 第二种是while的方式，只要满足条件就不断循环；

　　第一种案例：

for item in [\'111\', \'222\', \'333\']:
    print( item )

　　输出：  111

　　　　　 222
　　　　    333

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

　　输出：2500

　　说明: 在循环过程中可以根据条件提前结束循环 break，即可。或者根据条件继续循环 contionue 即可。

 

四、dist  和  set

　　dist 可以理解成map, 使用 键->值 对的形式存储，查询数据相对较快

#dict 和 set 的使用
dictInfo = {\'name\':\'cici\', \'age\': \'25\', \'sex\':\'女\'}
print(dictInfo)
print(dictInfo[\'name\'])

　　输出：{\'name\': \'cici\', \'age\': \'25\', \'sex\': \'女\'}

　　　　　　cici

dictInfo = {\'name\':\'cici\', \'age\': \'25\', \'sex\':\'女\'}
print(dictInfo)
dictInfo[\'name\'] = \'dada\'
print(dictInfo)

　　输出：{\'sex\': \'女\', \'age\': \'25\', \'name\': \'cici\'}

　　　　    {\'sex\': \'女\', \'age\': \'25\', \'name\': \'dada\'}

　　说明：如果定位查找某一个元素，如果元素不存在是会报错滴；

#验证key不存在的的方法
print( \'name\' in dictInfo )
print( \'test\' in dictInfo )
print( dictInfo.get(\'name\') )
print( dictInfo.get(\'test\') )
print( dictInfo.get(\'test\', \'没有\') )

　　输出：

　　　　True
　　　　False
　　　　dada
　　　　None
　　　　没有

　　删除的案例如下：

print( dictInfo )
dictInfo.pop(\'name\')
print( dictInfo )

　　输出：    {\'name\': \'dada\', \'sex\': \'女\', \'age\': \'25\'}

　　　　　　{\'sex\': \'女\', \'age\': \'25\'}

       和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

　　而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

 　　set   

　　　　set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

#set
#初始化set赋值
setInfo1 = set( [ 111, 222, 333 ] )
print( setInfo1 )

#set没有vlue 只有key 切 key 不可重复
setInfo2 = set( [111,222,333,333,222] )
print( setInfo2 )

#给set添加元素
setInfo2.add(\'444\')
print( setInfo2 )

#删除set元素
setInfo2.remove(\'444\')
print( setInfo2 )

　　输出：

　　　　{333, 222, 111}
　　　　{333, 222, 111}
　　　　{\'444\', 333, 222, 111}
　　　　{333, 222, 111}

 五、调用函数

#调用函数
print( abs(100 ) )
print( abs(-100) )
print( max(1,2,3,4,5,0,-1,-3) )
print( int(\'123\') )
print( float(\'12.34\') )
print( str(12.34) )
print( bool(1) )
print( bool(\'\') )

　　输出：

　　　　100
　　　　100
　　　　5
　　　　123
　　　　12.34
　　　　12.34
　　　　True
　　　　False

六、定义函数　　

#定义函数
def myFun(x):
    if x <= 60:
        print(\'小于60\')
    else :
        print(\'大于60\')

print( myFun(30) )

　　输出：小于60

 　　1）定义一个空函数，且什么都不做

def nop():
    pass

　　pass的作用就是什么都不做也不会出错，如果没有pass会出错的，所以pass就是占了一个坑

 　　2）检测不恰当的参数

def myFun(x):
    if not isinstance(x, (int, float)):
        raise TypeError(\'bad operand type\')
    if x >= 0:
        return x
    else:
        return -x

　　加了参数检查后，如果传入错误的参数类型，函数就可以抛出一个错误

 　　输出：

Traceback (most recent call last):
  File "/mnt/hgfs/webspace/pythonStudy/one.py", line 240, in <module>
    myFun(\'你好\')
  File "/mnt/hgfs/webspace/pythonStudy/one.py", line 234, in myFun
    raise TypeError(\'bad operand type\')
TypeError: bad operand type

　　2）返回多个参数

import math
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

x, y = move(100, 100, 60, math.pi / 6)
print( x, y)

　　import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数

七、函数参数

　　可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

#函数的参数
#默认参数，可变参数
#默认参数不做解释，可变参数案例如下
#可变参数就像定义一个list或者tuple一样，只是在参数的前面加了一个*

def myFun(*number):
    for item in number:
        print( item )

myFun(111,222,333)

　　输出：

　　　　111
　　　　222
　　　　333

#关键字参数
#而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def myFun( name, age, **kw) :
    print(\'name:\',name )
    print(\'age:\', age)
    print(\'kw:\', kw)
myFun(\'cici\', 18, nihao = \'aaaa\')

　　输出：

　　　　name: cici
　　　　age: 18
　　　　kw: {\'nihao\': \'aaaa\'}