002函数及重定向及字符串

函数是实现某一功能的小程序，它可以用于求值，可以是一个过程；函数可以有参数，也可以没有参数，可以有返回值，也可以没有返回值；函数的参数可以是数值，也可以是指针。

许多时候，我们使用一个函数，只需要了解它的功能，及输入和输出，并不关注函数内部实现机制，这叫函数的黑盒性。

二、函数的声明（多文件函数声明）、定义、调用

三、函数的参数传递

1．按值传递

2．按地址传递

例：指针做函数参数

#include

void swap2(int *px, int *py)

{

int temp = *px;

*px = *py;

*py = temp;

}

main(void)

{

int x = 5, y = 6;

swap2(&x, &y);

cout << "x = " << x << endl;

cout << "y = " << y << endl;

}

3．引用传递

（1）什么是引用

引用，就是别名，它完全等价于被引用的对象。引用类型用标识符&表示。

（2）定义

类型& 引用名=变量；

在声明引用时，必须同时进行初始化

void类型、数组、指针、引用等不能建立引用

（3）引用主要有三种用途

－变量或对象的别名；

－引用作函数的参数；

－函数的引用类型返回值。

（4）举例

int studentname;

int& sn=studentname;

float studentscore=99;

float &ss=studentscore;

ss=59;

例：引用作变量、对象别名

#include

void main(void)

{

cout<<“i=”<

cout<<“j=”<

j = 6;

cout<<“i=”<

cout<<“j=”<

int &k = j;

cout<<“i=”<

cout<<“j=”<

cout<<“k=”<

k=7;

cout<<“i=”<

cout<<“j=”<

cout<<“k=”<

}

●引用作函数参数（对比）

编程，实现两个变量值的交换。

#include “iostream.h”

void swap(int &x,int& y)

{ int t;

t=x;x=y;y=t;}

main()

{ int a,b;

cout<<”请输入两个数：\n”;

cin>>a>>b;

cout<<”你输入的两个数是：”<

swap(a,b);

cout<<”交换后的两个数是：”<

}

●函数返回值为引用类型

优点：

－函数返回的是所返回的变量或对象本身，而不需要建立临时的对象。这样减少了程序运行的开销；－如果一个函数返回的是一个引用类型，那么该函数可以被当作左值使用

#include

int a[]={1,3,5,7,9};

int& index(int);

void main(void)

{

cout<

index(2)=25;

cout<

}

int& index(int i)

{

return a[i];

}

四、递归调用

1．递归调用：就是子函数自己调用自己。

2．例：

求1+2+3+……+10的和。

求1*2*3*……*10的积。

五、函数重载

1．带缺省参数值的函数

C++允许实参个数与形参个数不同，方法是在说明函数原型时，为一个或多个形参指定缺省值。

如：int add(int a=5,int b=6,int c=7);

int add(int a,int b=6,int c=7);

int add(int,int,int c=7);

说明：

所有取缺省值的参数都必须在无缺省值的参数的右边。int add(int a=5,int,int c=7);错

调用函数时，从左到右将实参与形参结合，某个参数省略，则其后的参数都要省略。add( , , 10);错

例：

#include “iostream.h”

int add(int a=4,int b=7,int c=9);

main()

{

cout<

}

int add(int a,int b,int c)

{

return a+b+c;

}

例：

#include

void Fun(int x, int y = 0) //参数y为缺省参数

{

cout << "x = " << x << endl;

cout << "y = " << y << endl;

}

void main(void)

{

int x = 5, y = 6;

Fun(x, y); //参数y未缺省按y=6调用

Fun(x); //参数y缺省按y=0调用

}

2．函数重载

所谓函数重载，就是指一组函数名同名，但参数可区分的函数。参数可区包括参数类型可区分和参数个数可区分。说明：

带缺省值参数的函数与函数重载一起使用时可能会产生二义性。函数重载时最好不要使用缺省参数。

函数调用时，如果实参与形参类型不匹配，C++编译器会自动作类型转换，如果成功，就继续执行，但也可能产生不可识别的错误。

例：

//求多个数的和

#include “iostream.h”

int add(int,int);

int add(int,int,int);

int add(int,int,int,int);

main()

{

int a,b,c,d;

cout<<“请输入四个数：”<

cin>>a>>b>>c>>d;

cout<

cout<

cout<

}

例：

#include

int max(int x, int y)

{

if(x > y) return x;

else return y;

}

float max(float x, float y)

{

if(x > y) return x;

else return y;

}

int max(int x, int y, int z)

{

int t;

t=x;

if(t

t=y;

if(t

t=z;

return t;

}

void main(void)

{

int x = 5, y = 6, z = 7, t2, t3;

float u = 5.5, v = 6.6, w;

t2 = max(x, y);

cout << "t2 = " << t2 << endl;

t3 = max(x, y, z);

cout << "t3 = " << t3 << endl;

w = max(u, v);

cout << "w = " << w << endl;

}

六、内联函数

1．使用内联函数是为了消除函数调用时的系统开销，以提高运行速度。

在函数定义前冠以inline，该函数就被声明为了内联函数。

定义为内联函数的只适用于短小的子函数，如果子函数体过大，则不适于定义为内联函数。

内联函数在第一次被调用之关必须进行声明，否则编译器不会将它处理为内联函数。

例：

//求任意圆面积。

#include “iostream.h”

inline double circle(double)//如果在声明区没有关键字inline即使后面定义函数是使用了inline编译时，系统不会把函数circle当作内联函数。void main()

{

double r,s;

cout<<“请输入圆半径：”<

cin>>r;

s=circle(r);

cout>>”圆的面积是：”>>s>>endl;

}

inline double circle(double x)

{

return 3.14*x*x;

}

例：

//判断输入的字符是否为数字字符

#include

using namespace std;

inline bool isnumber(char); // 此处无inline，则isnumber函数不会被解释为内联函数

int main()

{

for(char c; cin>>c && c!='\n'; )

if(isnumber(c)) cout<<"you entered a digit.\n";

else cout<<"you entered a non-digit.\n";

}

inline bool isnumber(char ch)

{

return ch>='0' && ch<='9' ? 1 : 0;

}

七、string串

1．自定义类型，空间长度任意，支持搜索、替换、插入、删除、求长度、判断空串等操作

定义：

初始化：

赋值方式，使用构造函数方式

2．begin()函数

格式：begin();

功能：返回一个指向字符串第一个元素的迭代器。

例：

string a=“abcdefg”;

cout<<*(a.begin()+2);

cout<

3．end()函数

格式：end();

功能：返回一个指向字符串末（最后一个元素的下一个）的迭代器。

cout<<*(a.end()-4)<<””<

4．insert()

格式：

basic_string &insert( size_type index, const basic_string &str );

功能：在字符串的位置index插入字符串str, 若index为0，则在第一个字符前插入

basic_string &insert( size_type index, const char *str );

basic_string &insert( size_type index1, const basic_string &str, size_type index2, size_type num );

功能：在字符串的位置index1插入字符串str的子串(从index2开始，长num个字符)

basic_string &insert( size_type index, const char *str, size_type num );

功能：在字符串的位置index插入字符串str的num个字符

iterator insert( iterator i, const char &ch );

功能：在迭代器i表示的位置前面插入一个字符ch

void insert( iterator i, size_type num, const char &ch );

功能：在迭代器i表示的位置前面插入num个字符ch的拷贝

basic_string &insert( size_type index, size_type num, char ch );

功能：在字符串的位置index插入num个字符ch的拷贝

5．replace()

第一种：

basic_string &replace( size_type index, size_type num, const basic_string &str );

即：replace( 起始位置,被替换字符数量,替换字符的字串);

例：

#include "iostream.h"

#include "string"

main()

{

string a="abcdefgh",b="SOSOSOSO";

a.replace(2,3,b);//也可以写成a.replace(2,3, "SOSOSOSO");

cout<

}

结果：a串中的cde三个字符被替换成了SOSOSOSO，屏幕输出abSOSOSOSOfgh

第二种：

basic_string &replace( size_type index1, size_type num1, const basic_string &str, size_type index2,size_type num2 ); 即：replace( 起始位置,被替换字符数量,替换字符的字串，字串的起始位置，字符数量);

这个方法是用“替换字符的字串”的一部分去替换“被替换字符”。

例：

#include "iostream.h"

#include "string"

main()

{

string a="abcdefgh",b="SOSOSOSO";

a.replace(2,3,b,3,4); //也可以写成a.replace(2,3, "SOSOSOSO",3,4);

cout<

}

结果：用了字串"SOSOSOSO"从第三个字符开始的后面四个字符，即OSOS替换a串中的从第二个字符开始后的三个字符屏幕输出abOSOSfgh

第三种：

basic_string &replace( size_type index, size_type num, const char *str );

即：replace( 起始位置,被替换字符数量,替换字符的字串指针);

例：

#include "iostream.h"

#include "string"

main()

{

string a="abcdefgh";

char *b="SOSOSOSO";

a.replace(2,3,b);

cout<

}

结果：用字符串指针b所指向的字符串替换a串中第二个字符后面的三个字符，屏幕输出abSOSOSOSOfgh

第四种：

basic_string &replace( size_type index, size_type num1, const char *str, size_type num2 );

即：replace( 起始位置,被替换字符数量,替换字符的字串指针,字符数量);

例：

#include "iostream.h"

#include "string"

main()

{

string a="abcdefgh";

char *b="SOSOSOSO";

a.replace(2,3,b,2);

cout<

}

结果：用字符串指针b所指向的字符串的前两个字符替换a串中第二个字符后面的三个字符，屏幕输出abSOfgh

第五种：

basic_string &replace( size_type index, size_type num1, size_type num2, char ch );

即：replace( 起始位置,被替换字符数量,替换字符数量,替换字符);

例：

#include "iostream.h"

#include "string"

{

string a="abcdefgh";

char b='W';

a.replace(2,3,9,b); //也可以写成 a.replace(2,3,9,'W');

cout<

}

结果：用9个W替换a串第二个字符后的三个字符，屏幕显示：abWWWWWWWWWfgh

6．find()

语法:

size_type find( const basic_string &str, size_type index );//第二个参数为可选项，如果不选，则从第一个字符开始查找

功能：返回str在字符串中第一次出现的位置（从index开始查找）。如果没找到则返回string::npos。String::npos值为-1.

size_type find( const char *str, size_type index ); //第二个参数为可选项

size_type find( const char *str, size_type index, size_type length );

功能：返回str在字符串中第一次出现的位置（从index开始查找，长度为length，length是指str取前length个字符）。如果没找到就返回string::npos size_type find( char ch, size_type index ); //第二个参数为可选项

功能：返回字符ch在字符串中第一次出现的位置（从index开始查找）。如果没找到就返回string::npos

7．length()/size()

语法:

size_type length();

功能：length()/size()函数返回字符串的长度.

8．erase()

语法:

iterator erase( iterator pos );

功能：删除pos指向的字符, 返回指向下一个字符的迭代器

iterator erase( iterator start, iterator end );

功能：删除从start到end的所有字符, 返回一个迭代器,指向被删除的最后一个字符的下一个位置

basic_string &erase( size_type index = 0, size_type num = npos );// 参数index 和 num 有默认值, 这意味着erase()可以这样调用：只带有index 以删除index后的所有字符，或者不带有任何参数以删除所有字符.

功能：删除从index索引开始的num个字符, 返回*this

例如:

string s("So, you like donuts, eh? Well, have all the donuts in the world!");

cout << "The original string is '" << s << "'" << endl;

s.erase( 50, 14 );

cout << "Now the string is '" << s << "'" << endl;

s.erase( 24 );

cout << "Now the string is '" << s << "'" << endl;

s.erase();

cout << "Now the string is '" << s << "'" << endl;

9．empty()

bool empty();

功能：如果字符串为空则empty()返回真(true)，否则返回假(false).

10．substr

语法:

basic_string substr( size_type index, size_type num = npos );

功能：substr()返回本字符串的一个子串，从index开始，长num个字符。如果没有指定，将是默认值 string::npos。这样，substr()函数将简单的返回从index开始的剩余的字符串。

例：

#include "iostream.h"

#include "algorithm"

#include "string"

using namespace std;

main()

{

string a,s1="Hello";

string s2="123";

a=s1;

cout<<(a==s1?"":"not")<<"equal\n";

cout<

reverse(a.begin(),a.end());

cout<

a="abcdefghijklmn";//空间长度任意

a.insert(a.begin()+2,'P');//插入字符

cout<

cout<

cout<<(s1.find("ell")!=-1?"":"not")<<"found\n";//搜索

cout<<(s1.find('c')!=-1?"":"not")<<"found\n";

int n=a.length();//求长度

cout<

a.erase(5，9);//删除

cout<

a.erase(5);

cout<

cout<

}

11．append()在字符串尾添加字符串

12．push_back()在字符串尾添加字符

13．swap()交换字符串

14．clear()清空字符串

15．assign()为字符串赋值

八、main（）函数与重定向

1．什么是重定向

改变从标准输入设备获取数据和向标准输出设备输出数据的默认方式。

2．命令行重定向

使用重定向符，输入符<，输出符>。

从文件中获取数据：程序名<文件名

向文件输出数据：程序名>文件名

例：

#include “iostream.h”

main()

{

int a,b;

while(cin>>a>>b)

cout<

}

如果此文件保存为file1，在命令行上输入file1result.txt即是从data.txt中读取数据，然后把结果输出到result.txt中。

3．利用main函数参数重定向

main函数的参数用于接收系统传递的数据。

main(int argc,char **agrv)——argc：参数数量；argv：指向数组的指针

例：

#include

using namespace std;

int main(int argc, char** argv)

{

for(int i=0; i

cout<

}

例：

#include

using namespace std;

int main(int argc, char** argv)

{

char *temp;

for(int i=0; i

cout<

for(int i=0;i

{temp=argv[i];

argv[i]=argv[argc-1-i];

argv[argc-1-i]=temp;

}

cout<<”\n\n交换后的情况是：”<

for(int i=0; i

cout<

}

例：

#include

#include

using namespace std;

int main(int argc, char** argv)

{

if(argc!=3)

cout<<"Usage: f0511 infile outfile\n";

else{

ifstream in(argv[1]);

ofstream out(argv[2]);

if(in && out)

out<

}

}

九、作业

1．输入10个整数，把最小的数与第一个数对换，把最大的数与最后一个数对换。（指针做函数参数）

3．用函数调用的方法，把从键盘任意输入的三个数按从大到小的顺序排序，然后输出。（引用传递）

4．五个人坐在一起，问第五个人的年龄，他说比第四个人小三岁，问第四个人多大，他说比第三个人小三岁，问第三个人多大，他说比第二个人小三岁，问第二个人，他说比第一个人小三岁，问第一个人多大，他说他44岁，请问第五个人的年龄。（递归调用）

5．编写一组重载函数，实现求矩形、圆、圆柱、长方体等物体的面积。

6．用内联函数求圆柱体体积。

7．从键盘任意输入一个字符串，把这个字符串中出现的第一个字母“a”替换成“xyz”，然后在字符串倒数第一个字符前面插入“this is my work”，最后求这个新字符串长度，并输出新字符串。

8．利用重定向，把键盘输入的信息写入文件“myfile.txt”。

acm常用字符串处理函数

sstrstr与strchar用法 原型：extern char *strstr(char *haystack, char *needle); 用法：#include 功能：从字符串haystack中寻找needle第一次出现的位置（不比较结束符NULL)。 说明：返回指向第一次出现needle位置的指针，如果没找到则返回NULL。 举例： #include #include main() { char *s="Golden Global View"; char *l="lob"; char *p; clrscr(); p=strstr(s,l); if(p) printf("%s",p); else printf("Not Found!"); getchar(); return 0; } 语法：int strstr(str1,str2) str1: 被查找目标string expression to search. str2:要查找对象The string expression to find. 该函数返回str2第一次在str1中的位置，如果没有找到，返回NULL The strstr() function returns the ordinal position within str1 of the first occurrence of str2. If str2 is not found in str1, strstr() returns 0. 例子： 功能：从字串” string1 onexxx string2 oneyyy”中寻找”yyy” (假设xxx和yyy都是一个未知的字串) char *s=” string1 onexxx string2 oneyyy”; char *p; p=strstr(s,”string2”); if(!p) printf(“Not Found!”); p=strstr(p,”one”); if(!p) printf(“Not Found!”); p+=strlen(“one”) printf(“%s”,p); 说明：如果直接写语句p=strstr(p,”one”)，则找到的是xxx，不符合要求 所以需采用二次查找法找到目标

C语言函数大全

C语言函数大全 1 字符测试函数 函数（及意义）函数分解Isalnum(){判断字符是否is alphbet(字母表) number(数字) 为字母或数字} Isalpha(){判断是否为英文is alphbet（字母表） 字母} Isblank(){空格和TAB} is blank(空格) Iscntrl() { 控制} is control(控制) Isdigit(){数字} is digit(数字) Isgraph(){除空格外的可打is graph(图表) 印字符} Islower(){是否为小写} is lowercase(小写) Isprintf(){可打印字符含空这个简单 字符} Ispunct(){标点或特殊符号is punctuation(标点) } Isspace(){检查是否为空字is space(空间) 符，即判断是否为空格，水平 定位字符“\t”,归位字符“\r ”,垂直定位字符“\v”,换行 字符“\n”，翻页“\f”} Isupper(){是否为大写字母is upper_case(大写) } Isxdigit(){十六进制} is hexadecimal digit(十六进制) Tolower(){将小写转换成 大写} Toupper(){将大写转换成这个简单（to change 或者to covert 或者 小写} transformation

字符串函数 Memchr(){在某一内存范围内查找一特定字符}Memory (储存)char（字符型炭）也可以是character (字符) Memcmp(){比较区域 str1,str2的前n个字节} Memory(同理)compare(比较) Memcpy(){由str2所指内存区域复 制n个字节到str1所指内存区域} Memory copy(复制) Memmove(){两个所指的内存区域 可重叠，但是内容会更改，函数 返回值为指向区域内存的指针} Memory move(移动) Memset(){把str所指的内存区域 的前N个字节设置成字符c} Set(设置)

C语言字符串的输入和输出

C语言字符串的输入和输出 字符串的输入和输出 %c人为加入\0进行输入输出 %s直接输入输出 *输入输出字符串时字符数组应有足够的存储空间，指针变量作为输入项时，指针必须已经指向确切的、足够大的存储空间 %s的使用 scanf("%s",地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 例:char str[15]; scanf("%s",str); abc123 1.不读入空格和回车,从空格处结束 2.输入字符串长度超过字符数组元素个数，不报错 3.当输入项为字符指针时，指针必须已指向确定的有足够空间的连续 存储单元 4.当为数组元素地址时，从此元素地址开始存放 2.printf("%s",地址值) 输出时遇到第一个'\0'为止 3.gets和puts函数 开头必须stdio.h #include"stdio.h"

1.gets(地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 4.当为数组元素地址时，从此元素地址开始存放 5.printf("%s",地址值) 输出时遇到第一个'\0'为止 6.gets和puts函数 开头必须stdio.h #include"stdio.h" 1.gets(地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 7.例: char str[10]; gets(str); 包括空格符 8. 2.puts(字符串起始地址) 遇第一个'\0'结束,自动加入换行符 9.字符串数组:数组中每个元素都是一个存放字符串的数组 可以将一个二维数组看作是字符串数组 10.char ca[3][5]={"A","BB","CCC"}; A\0 B B\0 C C C\0 字符型指针数组 char*pa[3]={"a","bb","ccc"}; pa[0]pa[1]pa[2] 可以重新赋值gets(pa[2]);

java 字符串常用函数及其用法

java中的字符串也是一连串的字符。但是与许多其他的计算机语言将字符串作为字符数组处理不同，Java将字符串作为String类型对象来处理。将字符串作为内置的对象处理允许Java提供十分丰富的功能特性以方便处理字符串。下面是一些使用频率比较高的函数及其相关说明。 String相关函数 1)substring() 它有两种形式，第一种是：String substring(int startIndex) 第二种是：String substring(int startIndex,int endIndex) 2)concat() 连接两个字符串 例:String s="Welcome to "; String t=s.concat("AnHui"); 3)replace() 替换 它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下： String replace(char original,char replacement) 例如：String s=”Hello”.replace(’l',’w'); 第二种形式是用一个字符序列替换另一个字符序列，形式如下： String replace(CharSequence original,CharSequence replacement) 4)trim() 去掉起始和结尾的空格 5)valueOf() 转换为字符串 6)toLowerCase() 转换为小写 7)toUpperCase() 转换为大写 8)length() 取得字符串的长度 例：char chars[]={’a',’b’.’c'}; String s=new String(chars); int len=s.length(); 9)charAt() 截取一个字符 例：char ch; ch=”abc”.charAt(1); 返回值为’b’ 10)getChars() 截取多个字符 void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) sourceStart 指定了子串开始字符的下标 sourceEnd 指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。

Python3 常用函数

Python3 常用函数.笔记 Python 3自学.笔记 type（）检查变量数据： >>> x = 10 >>> type(x) (cla ss ‘int’) exit( ) 执行到此命令时，程序终止：！！！ >>> a = 0 >>> w hile a < 20: a = a + 1 if a == 5: else：#执行到此命令时，程序终止 a = 100 >>> print(a) 5 abs（）返回一个数的绝对值： >>> abs(3) 3 >>> abs(-3) 3 while _ _ _ : 循环执行程序： >>> n = 0 >>> w hile n < 3:#（a n d/o r/n o t） n = n + 1 print(n) Continue 继续下一轮循环 Break 退出整个循环 round（）对小数进行四舍五入操作： >>> x = 3.1415926 >>> round(x , 2) #保留2位小数

3.14 for _ _ _ in _ _ _ : 可以遍历任何序列的项目（如一个列表或者一个字符串）： >>> s = 'a bc def123456' >>> for i in s: print(i) a b c d ...... range( ) 返回一个可迭代对象： >>> range(20) range(0, 20) #默认以0开始 >>> a = 20 >>> for i in ra nge(0 , a , 5): #步长为：5（默认步长为1）print(i) 5 10 15 #计数到20但不包括20 >>> break 退出整个循环： >>> i = 0 >>> w hile i < 10: i = i + 1 if i == 5: Break #执行到此时退出循环结构 >>> print(i) 5 字符串：

c语言字符函数和字符串函数及应用

ANSIC标准要求在使用字符串函数时要包含头文件”string.h”,在使用字符函数时要包含头文件”ctype.h”,有的C编译不遵循ANSI C标准的规定，而用其他的名称的头文件。请使用时查有关手册。 C语言中的字符与字 符串函数 (string.h,ctype.h) 函数名 函数和形参类型功能返回值包含文件 isalnum int isalnum(ch) int ch; 检查ch是否 是字母 (alpha)或数 字 (numeric). 是字母或数 字返回1;否 则返回0. ctype.h isalpha int isalpha(ch) int ch; 检查ch是否 是字母. 是,返回1; 否,返回0. ctype.h iscntrl int iscntrl(ch) int ch; 检查ch是否 控制字符(其 ASCII码在0 和0x1F之 间). 是,返回1; 否,返回0. ctype.h isgraph int isgraph(ch) int ch; 检查ch是否 可打印字符 (其ASCII码 在ox21和 ox7E之间), 不包括空格. 是,返回1; 否,返回0. ctype.h islower int islower(ch) int ch; 检查ch是否 小写字母 (a~z). 是,返回1; 否,返回0. ctype.h isprint int isprint(ch) int ch; 检查ch是否 可打印字符 (包括空格), 其ASCII码 在 ox20~ox7E 之间. 是,返回1; 否,返回0. ctype.h ispunct int ispunct(ch) int ch; 检查ch是否 标点字符(不 包括空格), 即除字母,数 字和空格以 是,返回1; 否,返回0. ctype.h

SQL无序字符比较函数

go --创建函数(第一版) create function get_orderstr(@str varchar(8000)) returns varchar(8000) as begin set @str=rtrim(@str) declare @tb table(s varchar(1),a int) while len(@str)>0 begin insert into @tb select left(@str,1),ascii(left(@str,1)) set @str=right(@str,len(@str)-1) end declare @sql varchar(8000) select @sql=isnull(@sql+'','')+s from @tb order by a return isnull(@sql,'') end --测试示例 if(dbo.get_orderstr('abc')=dbo.get_orderstr('acb')) print'相同' else print'不同' --运行结果 /* 相同 */ --第二版 /* * 功能：不按先后顺序比较字符串序列是否相同 * * 适用：SQL Server 2000 / SQL Server 2005 * * 返回：相同不相同 * * 作者：Flystone * * 描述：学习Limpire(昨夜小楼)的方法后做一个动态SQL的* */ go --创建存储过程(这个不是函数) CREATE proc sp_CompareString @Str1 varchar(100), @Str2 varchar(100), @Split varchar(10),

最新python常用函数资料

1.map()函数map()是Python 内置的高阶函数，它接收一个函数f和一个list，并通过把函数 f 依次作用在list 的每个元素上，得到一个新的list 并返回。 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方，就可以用map()函数： 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算： def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81] 可以用列表替代 注意：map()函数不改变原有的list，而是返回一个新的list。

利用map()函数，可以把一个list 转换为另一个list，只需要传入转换函数。 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的list，事实上它可以处理包含任意类型的list，只要传入的函数f可以处理这种数据类型。 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list： 输入：['adam', 'LISA', 'barT'] 输出：['Adam', 'Lisa', 'Bart'] format_name(s)函数接收一个字符串，并且要返回格式化后的字符串，利用map()函数，就可以输出新的list。 参考代码: def format_name(s): return s[0].upper() + s[1:].lower() print map(format_name, ['adam', 'LISA', 'barT']) 2.reduce()函数 reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和map()类似，一个函数f，一个list，但行为和map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list 的每个元素反复调用函数f，并返回最终结果值。 例如，编写一个f函数，接收x和y，返回x和y的和： def f(x, y): return x + y 调用reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

C语言字符串操作总结大全(超详细)

C语言字符串操作总结大全(超详细) 1）字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度字符串 strlen(p) 取字符串长度 strcmp(p, p1) 比较字符串 strcasecmp忽略大小写比较字符串 strncmp(p, p1, n) 比较指定长度字符串 strchr(p, c) 在字符串中查找指定字符 strrchr(p, c) 在字符串中反向查找 strstr(p, p1) 查找字符串 strpbrk(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找该集合的任一元素strspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找不属于该集合的任一元素的偏移 strcspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找属于该集合的任一元素的偏移 * 具有指定长度的字符串处理函数在已处理的字符串之后填补零结尾符 2）字符串到数值类型的转换 strtod(p, ppend) 从字符串p 中转换double 类型数值，并将后续的字符串指针存储到ppend 指向的char* 类型存储。 strtol(p, ppend, base) 从字符串p 中转换long 类型整型数值，base 显式设置转换的整型进制，设置为0 以根据特定格式判断所用进制，0x, 0X 前缀以解释为十六进制格式整型，0 前缀以解释为八进制格式整型 atoi(p) 字符串转换到int 整型 atof(p) 字符串转换到double 符点数 atol(p) 字符串转换到long 整型 3）字符检查 isalpha() 检查是否为字母字符 isupper() 检查是否为大写字母字符 islower() 检查是否为小写字母字符 isdigit() 检查是否为数字 isxdigit() 检查是否为十六进制数字表示的有效字符 isspace() 检查是否为空格类型字符 iscntrl() 检查是否为控制字符 ispunct() 检查是否为标点符号 isalnum() 检查是否为字母和数字 isprint() 检查是否是可打印字符 isgraph() 检查是否是图形字符，等效于isalnum() | ispunct()

字符串处理函数大全

字符串处理函数大全 bcmp（比较内存内容）相关函数 bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp 表头文件;include 定义函数;int bcmp ( const void *s1,const void * s2,int n); 函数说明;bcmp()用来比较s1和s2所指的内存区间前n个字节，若参数n为0，则返回0。返回值;若参数s1 和s2 所指的内存内容都完全相同则返回0 值，否则返回非零值。 附加说明;建议使用memcmp()取代。 范例:参考memcmp()。 //================================================================ bcopy（拷贝内存内容）相关函数 memccpy，memcpy，memmove，strcpy，ctrncpy 表头文件;#include 定义函数;void bcopy ( const void *src,void *dest ,int n); 函数说明;bcopy()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址，不过参数src与dest在传给函数时是相反的位置。 返回值 ;附加说明建议使用memcpy()取代 范例 #include main() { char dest[30]=”string(a)”; char src[30]=”string\0string”; int i; bcopy(src,dest,30);/* src指针放在前*/ printf(bcopy(): “) for(i=0;i<30;i++) printf(“%c”,dest[i]); memcpy(dest src,30); /*dest指针放在钱*/ printf(…\nmemcpy() : “); for(i=0;i<30;i++) printf(“%c”,dest[i]); 执行 bcopy() : string string memcpy() :string sring //================================================================ bzero（将一段内存内容全清为零）相关函数 memset，swab 表头文件;#include 定义函数;void bzero(void *s,int n)； 函数说明:bzero()会将参数s所指的内存区域前n个字节，全部设为零值。相当于调用memset((void*)s,0,size_tn); 返回值:附加说明建议使用memset取代

python常用函数年初大总结

1.常用内置函数：(不用import就可以直接使用) help(obj) 在线帮助, obj可是任何类型 callable(obj) 查看一个obj是不是可以像函数一样调用 repr(obj) 得到obj的表示字符串，可以利用这个字符串eval重建该对象的一个拷贝 eval_r(str) 表示合法的python表达式，返回这个表达式 dir(obj) 查看obj的name space中可见的name hasattr(obj,name) 查看一个obj的name space中是否有name getattr(obj,name) 得到一个obj的name space中的一个name setattr(obj,name,value) 为一个obj的name space中的一个name指向vale这个object delattr(obj,name) 从obj的name space中删除一个name vars(obj) 返回一个object的name space。用dictionary表示 locals() 返回一个局部name space,用dictionary表示 globals() 返回一个全局name space,用dictionary表示 type(obj) 查看一个obj的类型 isinstance(obj,cls) 查看obj是不是cls的instance issubclass(subcls,supcls) 查看subcls是不是supcls的子类 类型转换函数 chr(i) 把一个ASCII数值,变成字符 ord(i) 把一个字符或者unicode字符,变成ASCII数值 oct(x) 把整数x变成八进制表示的字符串 hex(x) 把整数x变成十六进制表示的字符串

Python 常用函数

Python 函数 2016年4月14日 22:07 1、join（）函数 以下实例展示了join()的使用方法： #!/usr/bin/python str ="-"; seq =("a","b","c");# 字符串序列 print str.join( seq ); 以上实例输出结果如下： a-b-c 2、str.zfill(width) 将字符串str前面补0使得字符串长度为width 3、lambda函数（匿名函数） a. lambda表达式返回可调用的函数对象.但不会把这个函 数对象赋给一个标识符,而def则会把函数对象赋值给一个变 量. https://www.sodocs.net/doc/8211160103.html,mbda 它只是一个表达式,而def是一个语句 c.定义一些抽象的，不会别的地方再复用的函数 d. lambda语句中,冒号前是参数,可以有多个,用逗号隔开,冒 号右边的返回值 定义了一个lambda表达式，求三个数的和。 用lambda表达式求n的阶乘。 这里也可以把def直接写成lambda形式。如下 lambda函数可以很好和python中内建filter(),map(),reduce()函数的应用程序结合起来,因为它们都带了一个可执行的函数对象. 4、filter(function or None, sequence) -> list, tuple, or string 给定一个'过滤函数'和一个对象的序列,每个序列元素都通过这个过滤器进行筛选,保留函数返回为真的对象.filter函数为已知的序列的每个元素调用给定布尔函数.每个filter返回的非零(true)值元素添加到一个列表中. 1 2 3 #!/usr/bin/python2.5 from random import randint

Linux下常用C语言字符串操作函数

Linux下常用C语言字符串操作函数 stroul， strdup snprintf() atio C中常用字符串操作函数 #include size_t strlen(const char *s) 测量字符串长度s的实际长度。 例如s[20]="abc",那么strlen(s)的结果是3，而不是20.这就是实际长度 char *strcat(const char *s1, const *s2) 将字符串s2连接到s1的尾部。从s1的\0开始。 int strcmp(const *s1,const *s2) 比较s1和s2。 s1 = s2的时候返回值=0 s1 < s2的时候返回至<0 s1 > s2的时候返回值>0 char *strchr(const char *s, char c); 返回s中首次出现C的位置的指针。如果s中不存在c则返回NULL char *strrchr(const char *s, char c );返回s中最后一次出现c的位置的指针。如果没有，则返回0 char *strstr(const char *haystack, const char *needle);返回haystack中needle字符串首次出现的位置的指针（不比较结束符NULL）。若果没找到则返回NULL 限定长度的比较，拷贝和追加函数 int strncmp(char *s1, const char *s2, size_t n);(这些都是针对字符串的前n个字符来操作的) char *strncpy(char *dest, const char *src, size_t n); char *strncat(char *dest, const char *src, size_t n); char *strdup(char *s)返回指向被复制的字符串的指针，所需空间由malloc()分配而且需要free释放空间 int atoi(const char *nptr);将字符串转换成整型数

python字符串内置函数

a='helLO' print(a.title()) # 首字母大写a='1 2'

执行结果：1 2 1 2 1 2 00000001 2 1 2 3 4 5 6 7 8 # 3 字符串搜索相关 .find() # 搜索指定字符串，没有返回-1 .index() # 同上，但是找不到会报错 .rfind() # 从右边开始查找 .count() # 统计指定的字符串出现的次数 # 上面所有方法都可以用index代替，不同的是使用index查找不到会抛异常，而find s='hello world' print(s.find('e')) # 搜索指定字符串,没有返回-1 print(s.find('w',1,2)) # 顾头不顾尾，找不到则返回-1不会报错，找到了 则显示索引 print(s.index('w',1,2)) # 同上，但是找不到会报错 print(s.count('o')) # 统计指定的字符串出现的次数 print(s.rfind('l')) # 从右边开始查找 # 4字符串替换 .replace('old','new') # 替换old为new .replace('old','new',次数) # 替换指定次数的old为new s='hello world' print(s.replace('world','python')) print(s.replace('l','p',2)) print(s.replace('l','p',5)) 执行结果： hello python heppo world heppo worpd

# 5字符串去空格及去指定字符 .strip() # 去两边空格 .lstrip() # 去左边空格 .rstrip() # 去右边空格 .split() # 默认按空格分隔 .split('指定字符') # 按指定字符分割字符串为数组 s=' h e-l lo ' print(s) print(s.strip()) print(s.lstrip()) print(s.rstrip()) print(s.split('-')) print(s.split()) # 6字符串判断相关 .startswith('start') # 是否以start开头 .endswith('end') # 是否以end结尾 .isalnum() # 是否全为字母或数字 .isalpha() # 是否全字母 .isdigit() # 是否全数字 .islower() # 是否全小写 .isupper() # 是否全大写 .istitle() # 判断首字母是否为大写 .isspace() # 判断字符是否为空格 # 补充 bin() # 十进制数转八进制 hex() # 十进制数转十六进制 range() # 函数：可以生成一个整数序列 type() # 查看数据类型 len() # 计算字符串长度 format() # 格式化字符串，类似%s，传递值能多不能少

C语言函数大全

功能: 异常终止一个进程 用法: void abort(void) 函数名: abs 功能: 求整数的绝对值 用法: int abs(int i) 函数名: absread, abswirte 功能: 绝对磁盘扇区读、写数据 用法: int absread(int drive, int nsects, int sectno, void *buffer) int abswrite(int drive, int nsects, in tsectno, void *buffer 函数名: access 功能: 确定文件的访问权限 用法: int access(const char *filename, int amode) 函数名: acos 功能:反余弦函数 用法: double acos(double x) 函数名: allocmem 功能: 分配DOS存储段 用法:int allocmem(unsigned size, unsigned *seg) 函数名: arc 功能: 画一弧线 用法:void far arc(int x, int y, int stangle, int endangle, int radius)函数名: asctime 功能: 转换日期和时间为ASCII码 用法:char *asctime(const struct tm *tblock) 函数名: asin 功能:反正弦函数 用法: double asin(double x) 函数名: assert 功能: 测试一个条件并可能使程序终止 用法:void assert(int test) 函数名: atan 功能: 反正切函数 用法: double atan(double x)

C 中的string常用函数用法总结.

C++中的string常用函数用法总结首先，为了在我们的程序中使用string类型，我们必须包含头文件。 如下： #include //注意这里不是string.h string.h是C字符串头文件 #include using namespace std; 1．声明一个C++字符串 声明一个字符串变量很简单： string Str; 这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str 初始化为一个空字符串。String类的构造函数和析构函数如下： a) string s; //生成一个空字符串s b) string s(str) //拷贝构造函数生成str的复制品 c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值 d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多st rlen”的部分作为字符串的初值 e) string s(cstr) //将C字符串作为s的初值 f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。 g) string s(num,c) //生成一个字符串，包含num个c字符 h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值 i) s.~string() //销毁所有字符，释放内存 都很简单，我就不解释了。

python常用函数

1.map()函数 map()是Python 内置的高阶函数，它接收一个函数f和一个list，并通过把函数f 依次作用在li st 的每个元素上，得到一个新的list 并返回。 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方，就可以用map()函数： 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算： def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81] 可以用列表替代 注意：map()函数不改变原有的list，而是返回一个新的list。

利用map()函数，可以把一个list 转换为另一个list，只需要传入转换函数。 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的list，事实上它可以处理包含任意类型的list，只要传入的函数f可以处理这种数据类型。 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list： 输入：['adam', 'LISA', 'barT'] 输出：['Adam', 'Lisa', 'Bart'] format_name(s)函数接收一个字符串，并且要返回格式化后的字符串，利用map()函数，就可以输出新的list。 参考代码: def format_name(s): return s[0].upper() + s[1:].lower() print map(format_name, ['adam', 'LISA', 'barT']) 2.reduce()函数 reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和map()类似，一个函数f，一个list，但行为和map()不同，reduce()传入的函数f 必须接收两个参数，reduce()对list 的每个元素反复调用函数f，并返回最终结果值。 例如，编写一个f函数，接收x和y，返回x和y的和： def f(x, y): return x + y 调用reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

VB常用字符串函数解读

VB 常用字符串函数 (1 作者:来源:发布时间:07-11-03 浏览:12899 次 PART 1 1. ASC (X, Chr(X:转换字符字符码 [格式 ]: P=Asc(X 返回字符串 X 的第一个字符的字符码 P=Chr(X 返回字符码等于 X 的字符 [范例 ]: (1P=Chr(65 … 输出字符 A, 因为 A 的 ASCII 码等于 65 (2P=Asc(“A” … 输出 65 2. Len (X:计算字符串 X 的长度 [格式 ]: P=Len(X [说明 ]: 空字符串长度为 0, 空格符也算一个字符, 一个中文字虽然占用 2 Bytes, 但也算一个字符。 [范例 ]:

(1 令X=”” (空字符串 Len(X 输出结果为 0 (2 令X=”abcd” Len(X 输出结果为 4 (3 令X=”VB 教程” Len(X 输出结果为 4 3. Mid (X函数:读取字符串 X 中间的字符 [格式 ]: P=Mid(X,n 由 X 的第 n 个字符读起,读取后面的所有字符。P=Mid(X,n,m 由 X 的第 n 个字符读起,读取后面的 m 个字符。[范例 ]: (1 X=”abcdefg” P=Mid(X,5 结果为:P=”efg” (2 X=”abcdefg” P=Mid(X,2,4 结果为P=”bcde”

4. Replace : 将字符串中的某些特定字符串替换为其他字符串 [格式 ]: P=Replace(X,S,R [说明 ]:将字符串 X 中的字符串 S 替换为字符串 R ,然后返回。 [范例 ]: X=”VB is very good” P=Replace(X,good,nice 输出结果为:P=”VB is very nice” 5. StrReverse :反转字符串 [格式 ]: P=StrReverse(X [说明 ]: 返回 X 参数反转后的字符串 [范例 ]: (1 X=”abc” P=StrReverse(X 输出结果:P=”cba” 6. Ucase (X, Lcase(X:转换英文字母的大小写 [格式 ]: P=Lcase(X

python字符串常用函数

字符串常用函数 replace(string,old,new[,maxsplit]) 字符串的替换函数，把字符串中的old替换成new。默认是把string中所有的old值替换成new 值，如果给出maxsplit值，还可控制替换的个数，如果maxsplit为1，则只替换第一个old 值。 >>>a="11223344" >>>print string.replace(a,"1","one") oneone2223344 >>>print string.replace(a,"1","one",1) one12223344 capitalize(string) 该函数可把字符串的首个字符替换成大字。 >>> import string >>> print string.capitalize("python") Python split(string,sep=None,maxsplit=-1) 从string字符串中返回一个列表，以sep的值为分界符。 >>> import string >>> ip="192.168.3.3" >>> ip_list=string.split(ip,'.') >>> print ip_list ['192', '168', '3', '3'] all( iterable) 如果迭代的所有元素都是真就返回真。 >>> l = [0,1,2,3] >>> all(l) Flase >>> l = [1,2,3] >>> all(l) True any( iterable) 如果迭代中有一个元素为真就返回真。 >>> l = [0,1,2,3] >>> all(l) True >>> l = [1,2,3] >>> all(l) True basestring() 这个抽象类型是str和unicode的父类。它不能被调用或初始化，但是它可以使用来测试一

《字符串比较函数大全》

字符串比较函数 2009-05-02 12:06:17| 分类：技术|字号订阅 函数名: stpcpy 功能: 拷贝一个字符串到另一个 用法: char *stpcpy(char *destin, char *source); 程序例: #include #include int main(void) { char string[10]; char *str1 = "abcdefghi"; stpcpy(string, str1); printf("%s\n", string); return 0; } 函数名: strcat 功能: 字符串拼接函数

用法: char *strcat(char *destin, char *source); 程序例: #include #include int main(void) { char destination[25]; char *blank = " ", *c = "C++", *Borland = "Borland"; strcpy(destination, Borland); strcat(destination, blank); strcat(destination, c); printf("%s\n", destination); return 0; } 函数名: strchr 功能: 在一个串中查找给定字符的第一个匹配之处\ 用法: char *strchr(char *str, char c); 程序例: #include

Python内置的字符串处理函数整理字符串长度获取

Python内置的字符串处理函数整理字符串长度获取：len(str)例：print'%slengt By xuanfeng6666 at 2014-06-01 139 阅读 0 回复 0.0 希赛币 Python内置的字符串处理函数整理 ?字符串长度获取：len(str) 例：print '%s length=%d' % (str,len(str)) ?字母处理 全部大写：str.upper() 全部小写：str.lower() 大小写互换：str.swapcase() 首字母大写，其余小写：str.capitalize() 首字母大写：str.title() print '%s lower=%s' % (str,str.lower()) print '%s upper=%s' % (str,str.upper()) print '%s swapcase=%s' % (str,str.swapcase()) print '%s capitalize=%s' % (str,str.capitalize()) print '%s title=%s' % (str,str.title()) ?格式化相关 获取固定长度，右对齐，左边不够用空格补齐：str.rjust(width) 获取固定长度，左对齐，右边不够用空格补齐：str.ljust(width) 获取固定长度，中间对齐，两边不够用空格补齐：str.center(width) 获取固定长度，右对齐，左边不足用0补齐.zfill(width) print '%s ljust=%s' % (str,str.ljust(20))