python学习笔记(6)关键字与循环控制

一、变量和类型

　　1.基本变量类型

　　　　(1)整数

　　　　(2)浮点数

　　　　(3)字符串

　　　　(4)布尔值

　　　　(5)空值

　　　　(6)函数

　　　　(7)模块

　　　　(8)类型

　　　　(9)自定义类型

print(type(1234))
print(type(123.45))
print(type(123.))
print(type('abc'))
print(type(True))

　　<class 'int'>
　　<class 'float'>
　　<class 'float'>
　　<class 'str'>
　　<class 'bool'>

　　(10)python容器

print(type([1,2,3,4,'a','b']))#列表类型
print(type((1,'abc')))#元组类型
print(type(set(['a','b',3])))#set类型
print(type({'a':1,'b':2}))#字典类型

<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

　　(11)函数def，在python中，函数也是一个对象，函数和普通的变量是一样的，

def func(a,b,c):
    print(a,b,c)
print(type(func))#这里打印出function类型
<class 'function'>

#打印出函数的类型

def func(a,b,c):
    print(a,b,c)
a=func
print(type(a))
#<class 'function'>

　　(12)查看模块的类型

import  string

print(type(string))

　　<class 'module'>

　　(13)类和类的实例

class MyClass(object):
    pass
print(type(MyClass))#定义一个类属于'type'类
my_class=MyClass()
print(type(my_class))#而自己在实例化这个类之后，这个类就是之前定义类的类型

　　2.变量和类型

　　　　(1)变量定义：变量是存储在内存中的值，这意味着创建变量的时候会在内存中开辟空间。

　　　　 　　　　　　基于变量的数据类型，解释器会分配指定 的内存，并决定什么数据可以在存储器中。

　　　　　　　　　　变量可以指定不同的数据类型，这些变量可以存储整数、小数或者字符。

　　　　(2)变量赋值

　　　　　　　　　　每个变量在使用之都必须进行赋值，变量在赋值之后，变量才会被创建

　　　　　　　　　　下面例子中的变量没有被赋初始值，就会报错

try:
    x
    print(x)
except NameError:
    print('NameError:"x" is not define')

NameError:"x" is not define

　　　　　　等号=用来给变量赋值，等号(=)运算符的左边是一个变量名，等号右边的运算符是存储变量中的值

x=100
实际上是在堆内存中分配了一块空间，分配了一个int，int是4个字节，x是指向存放100的内存地址，所有的变量就是指向这个内存地址的
所有在栈中的东西，在函数调用结束之后都会被清理掉，在堆上分配的东西，生命周期就是全局的，只要不清理，不管函数有没有结束，东西都是放在那里的

　　3.字符串的处理

　　　　(1)除去空格以及特殊符号：strip，lstrip,rstrip

　　　　(2)复制字符串str1=str2

　　　　(3)连接字符串:str2+=str1　　new_str=str2+str1

　　　　(4)查找字符串：pos=str1.index(str2)

　　　　(5)比较字符串：cmp(str1,str2)

　　　　(6)字符串长度:len(str)

　　　　(7)字符串是不能被修改的。

import string
#字符串是不能被修改的
s='abc'
s[0]='x'

TypeError: 'str' object does not support item assignment，字符串不支持元素的赋值操作

　　　　(7)字符串的连接直接通过+加起来就可以

import  string
#字符串的连接
s1='abc'
s2='def'
print(s1+'
'+s2)

abc
def

　　(8)字符串的大小写

import  string
#字符串的大小写
s='aBc dHef'
print(s.upper())#通过upper()函数将函数全部转换为大写
print(s.upper().lower())#通过upper()函数将所有字母转换为大写，通过lower()函数将所有的字母转换为小写
print(s.capitalize())#capitalize()是将首字母转换为大写

ABC DHEF
abc dhef
Abc dhe

　　(9)字符串的比较：

import string
#位置比较
s_1='abcdefg'
s_2='abdeffxx'
print(s_1.index('bcd'))#查看bcd出现的位置，bcd出现的位置是1
#print(s_2.index('bcd'))#查看bcd出现的位置，s_2是没有bcd这个子字符串，所以这里就会出现异常、
#在python3中，cmp函数被移除了，直接用==号作比较就好
print(s_1==s_2)
print(s_1 < s_2)
print(s_1 > s_2)
print(len(s_1))

False
True
False

7

　　(10)空字符串和Falsle是等价的

import string

s=''
if not s:
    print('Empty')
elif s:
    print('not empty')

　　(10)字符串的分割和连接

import  string
#分割和连接
s='abc,def,ghi'
splitted=s.split(',')
print(type(splitted))#切割之后的类型是列表类型
print(splitted)#分割后的结果，

['abc', 'def', 'ghi']

<class 'list'>
['abc', 'def', 'ghi']

import  string
#分割和连接
s="""abc
    def
    ghi
    efg"""
s_1=s.split('
')
s_2=s.splitlines()#专门按照行来进行分割
print(s_1)　　#按照换行符来进行切割
print(s_2)　　　#与上面的这种方式是等价的

['abc', ' def', ' ghi', ' efg']
['abc', ' def', ' ghi', ' efg']

#连接操作，将列表中的字符串组合回去

import string
#分割和连接,将列表中的字符串组合回去
s=['abc','def','ghi']
print(''.join(s))#连接回去之后，不用任何连接符

print('-'.join(s))#以-号作为连接符合
print('
'.join(s))#以
作为连接符合

abcdefghi

abc-def-ghi
abc
def
ghi

(11)常用的判断

　　startswith()用于判断某个字符串是不是以某个值开头的

#字符串的常用判断
import string

s='abcdefg'
print(s.startswith('abc'))

　　'1234abcd'.isalnum()用于判断字符串是不是只含有字符串和数字

print('12345abcde'.isalnum())#只包含字母和数字
True

　　'abcd'.isalpha()用于判断是不是只有字符而没有数字的情况

print('abcd'.isalpha())#判断是不是只有字符没有数字的情况

　　'12345'.isdigit()用于判断是不是纯数字的情况

print('1236'.isdigit())#判断是不是纯数字

　　'     '.isspace()用于判断是不是只有space

print('   '.isspace())#判断是不是只有space

　　'abcd123456'.islower()用于判断字符串中的字母是不是都是小写的

print('abcd12345'.islower())#判断abcd是不是小写

　　'ABCD1234'.upper()用于判断字符串是不是都是大写的

print('Abnf12345'.isupper())#返回false

　　print('Hello World'.istitle())#判断是不是首字母大写

print('Hello World'.istitle())#判断是不是首字母大写

　　(12)数字转换到字符串

import string
#数字到字符串的变化,就是将数字转化为字符串或者将字符串转化为数字
print(str(5))
print(str(5.0))
print(str(5.1234))
print(str(-5.1234))

　　(13)字符串转换到数字

import  string

#字符串转换到数字
print(int('12346'))#将字符串转换为整数
print(float('1234.567'))#将字符串转换为浮点数
#print(int('123.45'))#这个地方会报错，将数字从浮点数转换为整数，系统不会自动做转换
#将数字做二进制的转换
print(int('110111',2))
print(int('ffff',16))#得到16进制值是65535，在数值后面要加上进制数

print(int('7777',8))#将8进制数字转换为10进制

　　(14)条件判断

　　　　if判断:

#if判断语句
a=100
b=200
c=300
if c==a:
    print(a)
elif c==b:
    print(b)
else:
    print(c)

　　　　None的判断：用is来进行直接的判断

#None的判断，可以用==也可以用is来进行判断
x=None
if x is None:
    print('None')
else:
    print('not None')

　　(14)for循环，

for i in range(start,end,step):

　　(15)函数

函数的定义格式：

　　默认参数

　　可变参数：args,自动组装成tuple

　　关键字参数：args,自动组装成dict

　　命名关键字参数

函数调用

　　函数名(参数名)

　　模块名(参数名)

　　带参数名调用

什么是递归？

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))

#打印出的结果：1  2
#print(type(r))
#打印出函数的类型

#函数的调用
def func(x,y=500):
    return x+y
print(func(100,600))
print(func(100))

#用字典来实现类似的功能
def func(p):
    print('x=',p['x'])
    print('y=',p['y'])

print(func({'x':100,'y':200}))

(16)定义可变参数函数

#可变参数,*表示将传进来的数字全部放进一个数组中去
def func(name,*numbers):
    print(type(numbers))
    print(numbers)
func('Tom',1,2,3,4,'abc')#元组，等价于一个只读数组

def my_print(*args):
    print(args)
my_print(1,2,3,4,'a','b','c')

#字典数据类型
def func(name,**kvs):#** means key/value
    print(name)
    print(type(kvs))
    print(kvs)
func('Tom',china='Beijing',uk='London')

 　　3.递归函数

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(10))

作业：(1)字符串按照单词进行反转，必须保留所有的空格。如:'I love china!     '转化为'    china! love I'

　　　　(2)打印100000之内的所有素数

　　　　(3)自己实现一个参数支持可变参数